import { ExtractPropTypes, Ref, ShallowRef, PropType, CreateComponentPublicInstanceWithMixins, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps, Plugin } from 'vue';
import { default as CacheEntity } from './Cache';
import { Linter } from './linters/interface';
import { 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;
    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;
    };
    mock: {
        type: 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: 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: PropType<HashPriority>;
        default: HashPriority;
    };
    /** Tell cssinjs where to inject style in */
    container: {
        type: 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: 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: PropType<Linter[]>;
        default: Linter[];
    };
};
export type StyleProviderProps = Partial<ExtractPropTypes<ReturnType<typeof styleProviderProps>>>;
export declare const StyleProvider: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
        autoClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        mock: {
            type: 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: 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: PropType<HashPriority>;
            default: HashPriority;
        };
        /** Tell cssinjs where to inject style in */
        container: {
            type: 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: 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: PropType<Linter[]>;
            default: Linter[];
        };
    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
        [key: string]: any;
    }>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
        autoClear: boolean;
        mock: "server" | "client";
        cache: CacheEntity;
        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";
        };
        /**
         * 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: 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: PropType<HashPriority>;
            default: HashPriority;
        };
        /** Tell cssinjs where to inject style in */
        container: {
            type: 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: 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: PropType<Linter[]>;
            default: Linter[];
        };
    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
        [key: string]: any;
    }>[] | undefined, {}, {}, {}, {
        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;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<{
    autoClear: {
        type: BooleanConstructor;
        default: boolean;
    };
    mock: {
        type: 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: 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: PropType<HashPriority>;
        default: HashPriority;
    };
    /** Tell cssinjs where to inject style in */
    container: {
        type: 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: 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: PropType<Linter[]>;
        default: Linter[];
    };
}>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
}>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
    autoClear: boolean;
    mock: "server" | "client";
    cache: CacheEntity;
    defaultCache: boolean;
    hashPriority: HashPriority;
    container: Element | ShadowRoot;
    ssrInline: boolean;
    transformers: Transformer[];
    linters: Linter[];
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & Plugin;
declare const _default: {
    useStyleInject: () => ShallowRef<Partial<StyleContextProps>>;
    useStyleProvider: (props: UseStyleProviderProps) => ShallowRef<Partial<StyleContextProps>, Partial<StyleContextProps>>;
    StyleProvider: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
            autoClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            mock: {
                type: 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: 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: PropType<HashPriority>;
                default: HashPriority;
            };
            /** Tell cssinjs where to inject style in */
            container: {
                type: 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: 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: PropType<Linter[]>;
                default: Linter[];
            };
        }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
            [key: string]: any;
        }>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
            autoClear: boolean;
            mock: "server" | "client";
            cache: CacheEntity;
            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";
            };
            /**
             * 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: 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: PropType<HashPriority>;
                default: HashPriority;
            };
            /** Tell cssinjs where to inject style in */
            container: {
                type: 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: 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: PropType<Linter[]>;
                default: Linter[];
            };
        }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
            [key: string]: any;
        }>[] | undefined, {}, {}, {}, {
            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;
    } & ComponentOptionsBase<Readonly<ExtractPropTypes<{
        autoClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        mock: {
            type: 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: 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: PropType<HashPriority>;
            default: HashPriority;
        };
        /** Tell cssinjs where to inject style in */
        container: {
            type: 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: 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: PropType<Linter[]>;
            default: Linter[];
        };
    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
        [key: string]: any;
    }>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
        autoClear: boolean;
        mock: "server" | "client";
        cache: CacheEntity;
        defaultCache: boolean;
        hashPriority: HashPriority;
        container: Element | ShadowRoot;
        ssrInline: boolean;
        transformers: Transformer[];
        linters: Linter[];
    }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & Plugin;
};
export default _default;
