rmwc/TextField/index.d.ts

A thin React wrapper for Material Design (Web) Components

import { SimpleTagPropsT } from '../Base';
import { IconPropsT } from '../Icon';
import * as React from 'react';
export declare type TextFieldPropsT = {
    /** Makes a multiline TextField. */
    textarea?: boolean;
    /** Sets the value for controlled TextFields. */
    value?: string | number;
    /** Makes the TextField fullwidth. */
    fullwidth?: boolean;
    /** Makes the TextField have a visual box. */
    box?: boolean;
    /** A ref for the native input. */
    inputRef?: React.Ref<any>;
    /** Disables the input. */
    disabled?: boolean;
    /** Mark the input as required. */
    required?: boolean;
    /** Makes the TextField visually invalid. This is sometimes automatically applied in cases where required or pattern is used.  */
    invalid?: boolean;
    /** Makes the TextField dense */
    dense?: boolean;
    /** Outline the TextField */
    outlined?: boolean;
    /** A label for the input. */
    label?: React.ReactNode;
    /** Add a leading icon. */
    withLeadingIcon?: React.ReactNode;
    /** Add a trailing icon. */
    withTrailingIcon?: React.ReactNode;
    /** By default, props spread to the input. These props are for the component's root container. */
    rootProps?: Object;
    /** An ID for the DOM element */
    id?: string;
} & SimpleTagPropsT;
export declare const TextFieldRoot: {
    new <P>(props: any, context?: any): {
        render(): React.ReactElement<any> | null;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: any) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callBack?: (() => void) | undefined): void;
        props: Readonly<{
            children?: React.ReactNode;
        }> & Readonly<any>;
        state: Readonly<{}>;
        context: any;
        refs: {
            [key: string]: React.ReactInstance;
        };
    };
    displayName: string;
    defaultProps: {
        /** Makes the TextField dense */
        tag: string | React.ComponentClass<any> | React.StatelessComponent<any>;
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: string | number | symbol): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: string | number | symbol): boolean;
    };
    isSimpleTag: boolean;
};
export declare const TextFieldInput: {
    new <P>(props: any, context?: any): {
        render(): React.ReactElement<any> | null;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: any) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callBack?: (() => void) | undefined): void;
        props: Readonly<{
            children?: React.ReactNode;
        }> & Readonly<any>;
        state: Readonly<{}>;
        context: any;
        refs: {
            [key: string]: React.ReactInstance;
        };
    };
    displayName: string;
    defaultProps: {
        /** Makes the TextField dense */
        tag: string | React.ComponentClass<any> | React.StatelessComponent<any>;
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: string | number | symbol): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: string | number | symbol): boolean;
    };
    isSimpleTag: boolean;
};
export declare const TextFieldTextarea: {
    new <P>(props: any, context?: any): {
        render(): React.ReactElement<any> | null;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: any) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callBack?: (() => void) | undefined): void;
        props: Readonly<{
            children?: React.ReactNode;
        }> & Readonly<any>;
        state: Readonly<{}>;
        context: any;
        refs: {
            [key: string]: React.ReactInstance;
        };
    };
    displayName: string;
    defaultProps: {
        /** Makes the TextField dense */
        tag: string | React.ComponentClass<any> | React.StatelessComponent<any>;
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: string | number | symbol): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: string | number | symbol): boolean;
    };
    isSimpleTag: boolean;
};
export declare const NotchedOutline: ({ children, ...rest }: {
    children: React.ReactNode;
}) => JSX.Element;
export declare const NotchedOutlinePath: ({ ...rest }: {}) => JSX.Element;
export declare const NotchedOutlineIdle: ({ ...rest }: {}) => JSX.Element;
export declare type TextFieldHelperTextPropsT = {
    /** Make the help text always visible */
    persistent?: boolean;
    /** Make the help a validation message style */
    validationMsg?: boolean;
};
declare const TextFieldHelperText_base: {
    new <P>(props: any, context?: any): {
        render(): React.ReactElement<any> | null;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: any) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callBack?: (() => void) | undefined): void;
        props: Readonly<{
            children?: React.ReactNode;
        }> & Readonly<any>;
        state: Readonly<{}>;
        context: any;
        refs: {
            [key: string]: React.ReactInstance;
        };
    };
    displayName: string;
    defaultProps: {
        /** Makes the TextField dense */
        tag: string | React.ComponentClass<any> | React.StatelessComponent<any>;
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: string | number | symbol): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: string | number | symbol): boolean;
    };
    isSimpleTag: boolean;
};
/**
 * A help text component
 */
export declare class TextFieldHelperText extends TextFieldHelperText_base<TextFieldHelperTextPropsT> {
    render(): React.ReactElement<any> | null;
}
export declare type TextFieldIconPropsT = {
    /** The icon to use */
    use: React.ReactNode;
} & IconPropsT;
declare const TextFieldIcon_base: {
    new <P>(props: any, context?: any): {
        render(): React.ReactElement<any> | null;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: any) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callBack?: (() => void) | undefined): void;
        props: Readonly<{
            children?: React.ReactNode;
        }> & Readonly<any>;
        state: Readonly<{}>;
        context: any;
        refs: {
            [key: string]: React.ReactInstance;
        };
    };
    displayName: string;
    defaultProps: {
        /** Makes the TextField dense */
        tag: string | React.ComponentClass<any> | React.StatelessComponent<any>;
        constructor: Function;
        toString(): string;
        toLocaleString(): string;
        valueOf(): Object;
        hasOwnProperty(v: string | number | symbol): boolean;
        isPrototypeOf(v: Object): boolean;
        propertyIsEnumerable(v: string | number | symbol): boolean;
    };
    isSimpleTag: boolean;
};
/**
 * An Icon in a TextField
 */
export declare class TextFieldIcon extends TextFieldIcon_base<TextFieldIconPropsT> {
    static displayName: string;
    render(): React.ReactElement<any> | null;
}
declare const TextField_base: {
    new <P>(props: P & {
        tag?: string | React.ComponentClass<any> | React.StatelessComponent<any> | undefined;
        className?: string | undefined;
        wrap?: boolean | undefined;
        elementRef?: any;
        theme?: string | string[] | undefined;
        children?: React.ReactNode;
        apiRef?: (<S>(api: S) => S) | undefined;
    } & React.HTMLProps<any>): {
        foundation_: {
            [key: string]: any;
            adapter_: any;
            init: Function;
            destroy: Function;
        } | null;
        foundationRefs: {
            [name: string]: (ref: HTMLElement) => any;
        };
        root_: Element | Text | null;
        props: P & {
            tag?: string | React.ComponentClass<any> | React.StatelessComponent<any> | undefined;
            className?: string | undefined;
            wrap?: boolean | undefined;
            elementRef?: any;
            theme?: string | string[] | undefined;
            children?: React.ReactNode;
            apiRef?: (<S>(api: S) => S) | undefined;
        } & React.HTMLProps<any>;
        componentDidMount(): void;
        componentWillReceiveProps(nextProps: P & {
            tag?: string | React.ComponentClass<any> | React.StatelessComponent<any> | undefined;
            className?: string | undefined;
            wrap?: boolean | undefined;
            elementRef?: any;
            theme?: string | string[] | undefined;
            children?: React.ReactNode;
            apiRef?: (<S>(api: S) => S) | undefined;
        } & React.HTMLProps<any>): void;
        componentWillUnmount(): void;
        _safeSyncWithProps(props: Object): void;
        initFoundation(): void;
        destroyComponent(): void;
        syncWithProps(nextProps: Object): void;
        initialize(...args: any[]): void;
        initialSyncWithDOM(): void;
        destroy(): void;
        getDefaultFoundation(): {
            adapter_: {};
            init: () => void;
            destroy: () => void;
        };
        emit(evtType: string, evtData: Object, shouldBubble?: boolean): any;
        listen(evtType: string, handler: Function): void;
        unlisten(evtType: string, handler: Function): void;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: P & {
            tag?: string | React.ComponentClass<any> | React.StatelessComponent<any> | undefined;
            className?: string | undefined;
            wrap?: boolean | undefined;
            elementRef?: any;
            theme?: string | string[] | undefined;
            children?: React.ReactNode;
            apiRef?: (<S>(api: S) => S) | undefined;
        } & React.HTMLProps<any>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callBack?: (() => void) | undefined): void;
        render(): React.ReactNode;
        state: Readonly<{}>;
        context: any;
        refs: {
            [key: string]: React.ReactInstance;
        };
    };
};
export declare class TextField extends TextField_base<TextFieldPropsT> {
    static displayName: string;
    valid: boolean;
    value: any;
    disabled: boolean;
    syncWithProps(nextProps: TextFieldPropsT): void;
    render(): JSX.Element;
}
export default TextField;