@cainiaofe/cn-ui-m/es/components/cn-typography/index.d.ts

## 在线文档

/// <reference types="react" />
import './styles/index.scss';
export declare const CnTypography: {
    Caption: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        displayName: string;
        contextType?: import("react").Context<any>;
    };
    BodyText1: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        displayName: string;
        contextType?: import("react").Context<any>;
    };
    BodyText2: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        displayName: string;
        contextType?: import("react").Context<any>;
    };
    H1: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        defaultProps: {
            prefix: string;
        };
        contextType?: import("react").Context<any>;
    };
    H2: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        defaultProps: {
            prefix: string;
        };
        contextType?: import("react").Context<any>;
    };
    H3: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        defaultProps: {
            prefix: string;
        };
        contextType?: import("react").Context<any>;
    };
    H4: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        defaultProps: {
            prefix: string;
        };
        contextType?: import("react").Context<any>;
    };
    H5: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        defaultProps: {
            prefix: string;
        };
        contextType?: import("react").Context<any>;
    };
    H6: {
        new (props: import("./text").TextProps | Readonly<import("./text").TextProps>): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        new (props: import("./text").TextProps, context: any): {
            render(): import("react").JSX.Element;
            context: any;
            setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./text").TextProps>) => {} | Pick<{}, K_1>) | Pick<{}, K_1>, callback?: () => void): void;
            forceUpdate(callback?: () => void): void;
            readonly props: Readonly<import("./text").TextProps> & Readonly<{
                children?: import("react").ReactNode;
            }>;
            state: Readonly<{}>;
            refs: {
                [key: string]: import("react").ReactInstance;
            };
            componentDidMount?(): void;
            shouldComponentUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
            getSnapshotBeforeUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>): any;
            componentDidUpdate?(prevProps: Readonly<import("./text").TextProps>, prevState: Readonly<{}>, snapshot?: any): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("./text").TextProps>, nextContext: any): void;
            componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./text").TextProps>, nextState: Readonly<{}>, nextContext: any): void;
        };
        defaultProps: {
            prefix: string;
        };
        contextType?: import("react").Context<any>;
    };
};