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