@vunk/plus 1.13.1 → 1.14.0

package/antx/_util/cssinjs/StyleContext.d.ts

@@ -0,0 +1,508 @@
+import type { ShallowRef, ExtractPropTypes, Ref } from 'vue';
+import CacheEntity from './Cache';
+import type { Linter } from './linters/interface';
+import type { Transformer } from './transformers/interface';
+export declare const ATTR_TOKEN = "data-token-hash";
+export declare const ATTR_MARK = "data-css-hash";
+export declare const ATTR_CACHE_PATH = "data-cache-path";
+export declare const CSS_IN_JS_INSTANCE = "__cssinjs_instance__";
+export declare function createCache(): CacheEntity;
+export type HashPriority = 'low' | 'high';
+export interface StyleContextProps {
+    autoClear?: boolean;
+    /** @private Test only. Not work in production. */
+    mock?: 'server' | 'client';
+    /**
+     * Only set when you need ssr to extract style on you own.
+     * If not provided, it will auto create <style /> on the end of Provider in server side.
+     */
+    cache: CacheEntity;
+    /** Tell children that this context is default generated context */
+    defaultCache: boolean;
+    /** Use `:where` selector to reduce hashId css selector priority */
+    hashPriority?: HashPriority;
+    /** Tell cssinjs where to inject style in */
+    container?: Element | ShadowRoot;
+    /** Component wil render inline  `<style />` for fallback in SSR. Not recommend. */
+    ssrInline?: boolean;
+    /** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
+    transformers?: Transformer[];
+    /**
+     * Linters to lint css before inject in document.
+     * Styles will be linted after transforming.
+     * Please note that `linters` do not support dynamic update.
+     */
+    linters?: Linter[];
+}
+export type UseStyleProviderProps = Partial<StyleContextProps> | Ref<Partial<StyleContextProps>>;
+export declare const useStyleInject: () => ShallowRef<Partial<StyleContextProps>>;
+export declare const useStyleProvider: (props: UseStyleProviderProps) => ShallowRef<Partial<StyleContextProps>, Partial<StyleContextProps>>;
+export declare const styleProviderProps: () => {
+    autoClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** @private Test only. Not work in production. */
+    mock: {
+        type: import("vue").PropType<"server" | "client">;
+        default: "server" | "client";
+    };
+    /**
+     * Only set when you need ssr to extract style on you own.
+     * If not provided, it will auto create <style /> on the end of Provider in server side.
+     */
+    cache: {
+        type: import("vue").PropType<CacheEntity>;
+        default: CacheEntity;
+    };
+    /** Tell children that this context is default generated context */
+    defaultCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Use `:where` selector to reduce hashId css selector priority */
+    hashPriority: {
+        type: import("vue").PropType<HashPriority>;
+        default: HashPriority;
+    };
+    /** Tell cssinjs where to inject style in */
+    container: {
+        type: import("vue").PropType<Element | ShadowRoot>;
+        default: Element | ShadowRoot;
+    };
+    /** Component wil render inline  `<style />` for fallback in SSR. Not recommend. */
+    ssrInline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
+    transformers: {
+        type: import("vue").PropType<Transformer[]>;
+        default: Transformer[];
+    };
+    /**
+     * Linters to lint css before inject in document.
+     * Styles will be linted after transforming.
+     * Please note that `linters` do not support dynamic update.
+     */
+    linters: {
+        type: import("vue").PropType<Linter[]>;
+        default: Linter[];
+    };
+};
+export type StyleProviderProps = Partial<ExtractPropTypes<ReturnType<typeof styleProviderProps>>>;
+export declare const StyleProvider: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
+        autoClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** @private Test only. Not work in production. */
+        mock: {
+            type: import("vue").PropType<"server" | "client">;
+            default: "server" | "client";
+        };
+        /**
+         * Only set when you need ssr to extract style on you own.
+         * If not provided, it will auto create <style /> on the end of Provider in server side.
+         */
+        cache: {
+            type: import("vue").PropType<CacheEntity>;
+            default: CacheEntity;
+        };
+        /** Tell children that this context is default generated context */
+        defaultCache: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** Use `:where` selector to reduce hashId css selector priority */
+        hashPriority: {
+            type: import("vue").PropType<HashPriority>;
+            default: HashPriority;
+        };
+        /** Tell cssinjs where to inject style in */
+        container: {
+            type: import("vue").PropType<Element | ShadowRoot>;
+            default: Element | ShadowRoot;
+        };
+        /** Component wil render inline  `<style />` for fallback in SSR. Not recommend. */
+        ssrInline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
+        transformers: {
+            type: import("vue").PropType<Transformer[]>;
+            default: Transformer[];
+        };
+        /**
+         * Linters to lint css before inject in document.
+         * Styles will be linted after transforming.
+         * Please note that `linters` do not support dynamic update.
+         */
+        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: CacheEntity;
+        defaultCache: boolean;
+        hashPriority: 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<ExtractPropTypes<{
+        autoClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** @private Test only. Not work in production. */
+        mock: {
+            type: import("vue").PropType<"server" | "client">;
+            default: "server" | "client";
+        };
+        /**
+         * Only set when you need ssr to extract style on you own.
+         * If not provided, it will auto create <style /> on the end of Provider in server side.
+         */
+        cache: {
+            type: import("vue").PropType<CacheEntity>;
+            default: CacheEntity;
+        };
+        /** Tell children that this context is default generated context */
+        defaultCache: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** Use `:where` selector to reduce hashId css selector priority */
+        hashPriority: {
+            type: import("vue").PropType<HashPriority>;
+            default: HashPriority;
+        };
+        /** Tell cssinjs where to inject style in */
+        container: {
+            type: import("vue").PropType<Element | ShadowRoot>;
+            default: Element | ShadowRoot;
+        };
+        /** Component wil render inline  `<style />` for fallback in SSR. Not recommend. */
+        ssrInline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
+        transformers: {
+            type: import("vue").PropType<Transformer[]>;
+            default: Transformer[];
+        };
+        /**
+         * Linters to lint css before inject in document.
+         * Styles will be linted after transforming.
+         * Please note that `linters` do not support dynamic update.
+         */
+        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: CacheEntity;
+        defaultCache: boolean;
+        hashPriority: HashPriority;
+        container: Element | ShadowRoot;
+        ssrInline: boolean;
+        transformers: Transformer[];
+        linters: Linter[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
+    autoClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** @private Test only. Not work in production. */
+    mock: {
+        type: import("vue").PropType<"server" | "client">;
+        default: "server" | "client";
+    };
+    /**
+     * Only set when you need ssr to extract style on you own.
+     * If not provided, it will auto create <style /> on the end of Provider in server side.
+     */
+    cache: {
+        type: import("vue").PropType<CacheEntity>;
+        default: CacheEntity;
+    };
+    /** Tell children that this context is default generated context */
+    defaultCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Use `:where` selector to reduce hashId css selector priority */
+    hashPriority: {
+        type: import("vue").PropType<HashPriority>;
+        default: HashPriority;
+    };
+    /** Tell cssinjs where to inject style in */
+    container: {
+        type: import("vue").PropType<Element | ShadowRoot>;
+        default: Element | ShadowRoot;
+    };
+    /** Component wil render inline  `<style />` for fallback in SSR. Not recommend. */
+    ssrInline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
+    transformers: {
+        type: import("vue").PropType<Transformer[]>;
+        default: Transformer[];
+    };
+    /**
+     * Linters to lint css before inject in document.
+     * Styles will be linted after transforming.
+     * Please note that `linters` do not support dynamic update.
+     */
+    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: CacheEntity;
+    defaultCache: boolean;
+    hashPriority: 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;
+declare const _default: {
+    useStyleInject: () => ShallowRef<Partial<StyleContextProps>>;
+    useStyleProvider: (props: UseStyleProviderProps) => ShallowRef<Partial<StyleContextProps>, Partial<StyleContextProps>>;
+    StyleProvider: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
+            autoClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            /** @private Test only. Not work in production. */
+            mock: {
+                type: import("vue").PropType<"server" | "client">;
+                default: "server" | "client";
+            };
+            /**
+             * Only set when you need ssr to extract style on you own.
+             * If not provided, it will auto create <style /> on the end of Provider in server side.
+             */
+            cache: {
+                type: import("vue").PropType<CacheEntity>;
+                default: CacheEntity;
+            };
+            /** Tell children that this context is default generated context */
+            defaultCache: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            /** Use `:where` selector to reduce hashId css selector priority */
+            hashPriority: {
+                type: import("vue").PropType<HashPriority>;
+                default: HashPriority;
+            };
+            /** Tell cssinjs where to inject style in */
+            container: {
+                type: import("vue").PropType<Element | ShadowRoot>;
+                default: Element | ShadowRoot;
+            };
+            /** Component wil render inline  `<style />` for fallback in SSR. Not recommend. */
+            ssrInline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            /** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
+            transformers: {
+                type: import("vue").PropType<Transformer[]>;
+                default: Transformer[];
+            };
+            /**
+             * Linters to lint css before inject in document.
+             * Styles will be linted after transforming.
+             * Please note that `linters` do not support dynamic update.
+             */
+            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: CacheEntity;
+            defaultCache: boolean;
+            hashPriority: 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<ExtractPropTypes<{
+            autoClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            /** @private Test only. Not work in production. */
+            mock: {
+                type: import("vue").PropType<"server" | "client">;
+                default: "server" | "client";
+            };
+            /**
+             * Only set when you need ssr to extract style on you own.
+             * If not provided, it will auto create <style /> on the end of Provider in server side.
+             */
+            cache: {
+                type: import("vue").PropType<CacheEntity>;
+                default: CacheEntity;
+            };
+            /** Tell children that this context is default generated context */
+            defaultCache: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            /** Use `:where` selector to reduce hashId css selector priority */
+            hashPriority: {
+                type: import("vue").PropType<HashPriority>;
+                default: HashPriority;
+            };
+            /** Tell cssinjs where to inject style in */
+            container: {
+                type: import("vue").PropType<Element | ShadowRoot>;
+                default: Element | ShadowRoot;
+            };
+            /** Component wil render inline  `<style />` for fallback in SSR. Not recommend. */
+            ssrInline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            /** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
+            transformers: {
+                type: import("vue").PropType<Transformer[]>;
+                default: Transformer[];
+            };
+            /**
+             * Linters to lint css before inject in document.
+             * Styles will be linted after transforming.
+             * Please note that `linters` do not support dynamic update.
+             */
+            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: CacheEntity;
+            defaultCache: boolean;
+            hashPriority: HashPriority;
+            container: Element | ShadowRoot;
+            ssrInline: boolean;
+            transformers: Transformer[];
+            linters: Linter[];
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
+        autoClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** @private Test only. Not work in production. */
+        mock: {
+            type: import("vue").PropType<"server" | "client">;
+            default: "server" | "client";
+        };
+        /**
+         * Only set when you need ssr to extract style on you own.
+         * If not provided, it will auto create <style /> on the end of Provider in server side.
+         */
+        cache: {
+            type: import("vue").PropType<CacheEntity>;
+            default: CacheEntity;
+        };
+        /** Tell children that this context is default generated context */
+        defaultCache: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** Use `:where` selector to reduce hashId css selector priority */
+        hashPriority: {
+            type: import("vue").PropType<HashPriority>;
+            default: HashPriority;
+        };
+        /** Tell cssinjs where to inject style in */
+        container: {
+            type: import("vue").PropType<Element | ShadowRoot>;
+            default: Element | ShadowRoot;
+        };
+        /** Component wil render inline  `<style />` for fallback in SSR. Not recommend. */
+        ssrInline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
+        transformers: {
+            type: import("vue").PropType<Transformer[]>;
+            default: Transformer[];
+        };
+        /**
+         * Linters to lint css before inject in document.
+         * Styles will be linted after transforming.
+         * Please note that `linters` do not support dynamic update.
+         */
+        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: CacheEntity;
+        defaultCache: boolean;
+        hashPriority: 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 default _default;

package/antx/_util/cssinjs/hooks/useCSSVarRegister.d.ts

@@ -0,0 +1,20 @@
+import type { TokenWithCSSVar } from '../util';
+import type { ExtractStyle } from './useGlobalCache';
+export declare const CSS_VAR_PREFIX = "cssVar";
+type CSSVarCacheValue<V, T extends Record<string, V> = Record<string, V>> = [
+    cssVarToken: TokenWithCSSVar<V, T>,
+    cssVarStr: string,
+    styleId: string,
+    cssVarKey: string
+];
+declare const useCSSVarRegister: <V, T extends Record<string, V>>(config: {
+    path: string[];
+    key: string;
+    prefix?: string;
+    unitless?: Record<string, boolean>;
+    ignore?: Record<string, boolean>;
+    scope?: string;
+    token: any;
+}, fn: () => T) => import("vue").ShallowRef<CSSVarCacheValue<V, T>>;
+export declare const extract: ExtractStyle<CSSVarCacheValue<any>>;
+export default useCSSVarRegister;

package/antx/_util/cssinjs/hooks/useCacheToken.d.ts

@@ -0,0 +1,40 @@
+import type Theme from '../theme/Theme';
+import type { Ref } from 'vue';
+export interface Option<DerivativeToken, DesignToken> {
+    /**
+     * Generate token with salt.
+     * This is used to generate different hashId even same derivative token for different version.
+     */
+    salt?: string;
+    override?: object;
+    /**
+     * Format token as you need. Such as:
+     *
+     * - rename token
+     * - merge token
+     * - delete token
+     *
+     * This should always be the same since it's one time process.
+     * It's ok to useMemo outside but this has better cache strategy.
+     */
+    formatToken?: (mergedToken: any) => DerivativeToken;
+    /**
+     * Get final token with origin token, override token and theme.
+     * The parameters do not contain formatToken since it's passed by user.
+     * @param origin The original token.
+     * @param override Extra tokens to override.
+     * @param theme Theme instance. Could get derivative token by `theme.getDerivativeToken`
+     */
+    getComputedToken?: (origin: DesignToken, override: object, theme: Theme<any, any>) => DerivativeToken;
+}
+export declare const getComputedToken: <DerivativeToken = object, DesignToken = DerivativeToken>(originToken: DesignToken, overrideToken: object, theme: Theme<any, any>, format?: (token: DesignToken) => DerivativeToken) => any;
+/**
+ * Cache theme derivative token as global shared one
+ * @param theme Theme entity
+ * @param tokens List of tokens, used for cache. Please do not dynamic generate object directly
+ * @param option Additional config
+ * @returns Call Theme.getDerivativeToken(tokenObject) to get token
+ */
+export default function useCacheToken<DerivativeToken = object, DesignToken = DerivativeToken>(theme: Ref<Theme<any, any>>, tokens: Ref<Partial<DesignToken>[]>, option?: Ref<Option<DerivativeToken, DesignToken>>): import("vue").ShallowRef<[DerivativeToken & {
+    _tokenKey: string;
+}, string]>;

package/antx/_util/cssinjs/hooks/useGlobalCache.d.ts

@@ -0,0 +1,6 @@
+import type { KeyType } from '../Cache';
+import type { ShallowRef, Ref } from 'vue';
+export type ExtractStyle<CacheValue> = (cache: CacheValue, effectStyles: Record<string, boolean>, options?: {
+    plain?: boolean;
+}) => [order: number, styleId: string, style: string] | null;
+export default function useClientCache<CacheType>(prefix: string, keyPath: Ref<KeyType[]>, cacheFn: () => CacheType, onCacheRemove?: (cache: CacheType, fromHMR: boolean) => void): ShallowRef<CacheType>;

package/antx/_util/cssinjs/hooks/useHMR.d.ts

@@ -0,0 +1,3 @@
+declare function useProdHMR(): boolean;
+declare const _default: typeof useProdHMR;
+export default _default;

package/antx/_util/cssinjs/hooks/useStyleRegister/cacheMapUtil.d.ts

@@ -0,0 +1,14 @@
+export declare const ATTR_CACHE_MAP = "data-ant-cssinjs-cache-path";
+/**
+ * This marks style from the css file.
+ * Which means not exist in `<style />` tag.
+ */
+export declare const CSS_FILE_STYLE = "_FILE_STYLE__";
+export declare function serialize(cachePathMap: Record<string, string>): string;
+/**
+ * @private Test usage only. Can save remove if no need.
+ */
+export declare function reset(mockCache?: Record<string, string>, fromFile?: boolean): void;
+export declare function prepare(): void;
+export declare function existPath(path: string): boolean;
+export declare function getStyleAndHash(path: string): [style: string | null, hash: string];

package/antx/_util/cssinjs/hooks/useStyleRegister/index.d.ts

@@ -0,0 +1,69 @@
+import type * as CSS from 'csstype';
+import type { Theme, Transformer } from '../..';
+import type Cache from '../../Cache';
+import type Keyframes from '../../Keyframes';
+import type { Linter } from '../../linters';
+import type { HashPriority } from '../../StyleContext';
+import type { Ref } from 'vue';
+import type { VueNode } from '../../../type';
+declare const SKIP_CHECK = "_skip_check_";
+declare const MULTI_VALUE = "_multi_value_";
+export type CSSProperties = Omit<CSS.PropertiesFallback<number | string>, 'animationName'> & {
+    animationName?: CSS.PropertiesFallback<number | string>['animationName'] | Keyframes;
+};
+export type CSSPropertiesWithMultiValues = {
+    [K in keyof CSSProperties]: CSSProperties[K] | readonly Extract<CSSProperties[K], string>[] | {
+        [SKIP_CHECK]?: boolean;
+        [MULTI_VALUE]?: boolean;
+        value: CSSProperties[K] | CSSProperties[K][];
+    };
+};
+export type CSSPseudos = {
+    [K in CSS.Pseudos]?: CSSObject;
+};
+type ArrayCSSInterpolation = readonly CSSInterpolation[];
+export type InterpolationPrimitive = null | undefined | boolean | number | string | CSSObject;
+export type CSSInterpolation = InterpolationPrimitive | ArrayCSSInterpolation | Keyframes;
+export type CSSOthersObject = Record<string, CSSInterpolation>;
+export interface CSSObject extends CSSPropertiesWithMultiValues, CSSPseudos, CSSOthersObject {
+}
+export declare function normalizeStyle(styleStr: string): string;
+export interface ParseConfig {
+    hashId?: string;
+    hashPriority?: HashPriority;
+    layer?: string;
+    path?: string;
+    transformers?: Transformer[];
+    linters?: Linter[];
+}
+export interface ParseInfo {
+    root?: boolean;
+    injectHash?: boolean;
+    parentSelectors: string[];
+}
+/**
+ * @private Test only. Clear the global effect style keys.
+ */
+export declare const _cf: () => void;
+export declare const parseStyle: (interpolation: CSSInterpolation, config?: ParseConfig, { root, injectHash, parentSelectors }?: ParseInfo) => [parsedStr: string, effectStyle: Record<string, string>];
+export declare function uniqueHash(path: (string | number)[], styleStr: string): string;
+/**
+ * Register a style to the global style sheet.
+ */
+export default function useStyleRegister(info: Ref<{
+    theme: Theme<any, any>;
+    token: any;
+    path: string[];
+    hashId?: string;
+    layer?: string;
+    nonce?: string | (() => string);
+    clientOnly?: boolean;
+    /**
+     * Tell cssinjs the insert order of style.
+     * It's useful when you need to insert style
+     * before other style to overwrite for the same selector priority.
+     */
+    order?: number;
+}>, styleFn: () => CSSInterpolation): (node: VueNode) => VueNode;
+export declare function extractStyle(cache: Cache, plain?: boolean): string;
+export {};