import useCacheToken from './hooks/useCacheToken';
import useStyleRegister, { extractStyle } from './hooks/useStyleRegister/index';
import Keyframes from './Keyframes';
import { legacyNotSelectorLinter, logicalPropertiesLinter, parentSelectorLinter } from './linters/index';
import { StyleProvider, createCache, useStyleInject, useStyleProvider } from './StyleContext';
import { Theme, createTheme } from './theme/index';
import legacyLogicalPropertiesTransformer from './transformers/legacyLogicalProperties';
import { px2remTransformer } from './transformers/px2rem';
import type { Linter } from './linters/interface';
import type { StyleContextProps, StyleProviderProps } from './StyleContext';
import type { DerivativeFunc, TokenType } from './theme/index';
import type { Transformer } from './transformers/interface';
import type { CSSInterpolation, CSSObject, CSSProperties } from './hooks/useStyleRegister/index';
export declare const cssinjs: {
    Theme: typeof Theme;
    createTheme: typeof createTheme;
    useStyleRegister: typeof useStyleRegister;
    useCacheToken: typeof useCacheToken;
    createCache: typeof createCache;
    useStyleInject: typeof useStyleInject;
    useStyleProvider: typeof useStyleProvider;
    Keyframes: typeof Keyframes;
    extractStyle: typeof extractStyle;
    legacyLogicalPropertiesTransformer: Transformer;
    px2remTransformer: typeof px2remTransformer;
    logicalPropertiesLinter: Linter;
    legacyNotSelectorLinter: Linter;
    parentSelectorLinter: Linter;
    StyleProvider: {
        new (...args: any[]): {
            $: import("vue").ComponentInternalInstance;
            $data: {};
            $props: {
                autoClear?: boolean;
                defaultCache?: boolean;
                ssrInline?: boolean;
                key?: string | number | symbol;
                style?: unknown;
                readonly cache?: import("./Cache").default;
                readonly mock?: "server" | "client";
                readonly hashPriority?: import("./StyleContext").HashPriority;
                readonly container?: Element | ShadowRoot;
                readonly transformers?: Transformer[];
                readonly linters?: Linter[];
                ref?: import("vue").VNodeRef;
                ref_for?: boolean;
                ref_key?: string;
                onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[];
                onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[];
                onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[];
                onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[];
                onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[];
                onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[];
                class?: unknown;
            };
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: import("vue").Slot<any>;
            }>;
            $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
            $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
            $emit: (event: string, ...args: any[]) => void;
            $el: any;
            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                autoClear: BooleanConstructor;
                mock: import("vue").PropType<"server" | "client">;
                cache: {
                    type: import("vue").PropType<import("./Cache").default>;
                };
                hashPriority: {
                    type: import("vue").PropType<import("./StyleContext").HashPriority>;
                };
                container: import("vue").PropType<Element | ShadowRoot>;
                ssrInline: BooleanConstructor;
                transformers: import("vue").PropType<Transformer[]>;
                linters: import("vue").PropType<Linter[]>;
                defaultCache: {
                    type: BooleanConstructor;
                };
            }>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                autoClear: boolean;
                defaultCache: boolean;
                ssrInline: boolean;
            }, {}, string, {}> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof import("vue").nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
        } & Readonly<import("vue").ExtractPropTypes<{
            autoClear: BooleanConstructor;
            mock: import("vue").PropType<"server" | "client">;
            cache: {
                type: import("vue").PropType<import("./Cache").default>;
            };
            hashPriority: {
                type: import("vue").PropType<import("./StyleContext").HashPriority>;
            };
            container: import("vue").PropType<Element | ShadowRoot>;
            ssrInline: BooleanConstructor;
            transformers: import("vue").PropType<Transformer[]>;
            linters: import("vue").PropType<Linter[]>;
            defaultCache: {
                type: BooleanConstructor;
            };
        }>> & import("vue").ShallowUnwrapRef<() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>[]> & {} & import("vue").ComponentCustomProperties & {};
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        autoClear: BooleanConstructor;
        mock: import("vue").PropType<"server" | "client">;
        cache: {
            type: import("vue").PropType<import("./Cache").default>;
        };
        hashPriority: {
            type: import("vue").PropType<import("./StyleContext").HashPriority>;
        };
        container: import("vue").PropType<Element | ShadowRoot>;
        ssrInline: BooleanConstructor;
        transformers: import("vue").PropType<Transformer[]>;
        linters: import("vue").PropType<Linter[]>;
        defaultCache: {
            type: BooleanConstructor;
        };
    }>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
        autoClear: boolean;
        defaultCache: boolean;
        ssrInline: boolean;
    }, {}, string, {}> & 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, CSSProperties, };
export declare const _experimental: {
    supportModernCSS: () => boolean;
};
