Interface TextInputProps

interface TextInputProps {
    about?: string;
    accept?: string;
    acceptCharset?: string;
    accessKey?: string;
    action?: string;
    allowFullScreen?: boolean;
    allowTransparency?: boolean;
    alt?: string;
    aria-activedescendant?: string;
    aria-atomic?: Booleanish;
    aria-autocomplete?:
        | "list"
        | "inline"
        | "none"
        | "both";
    aria-braillelabel?: string;
    aria-brailleroledescription?: string;
    aria-busy?: Booleanish;
    aria-checked?:
        | boolean
        | "true"
        | "false"
        | "mixed";
    aria-colcount?: number;
    aria-colindex?: number;
    aria-colindextext?: string;
    aria-colspan?: number;
    aria-controls?: string;
    aria-current?:
        | boolean
        | "step"
        | "time"
        | "location"
        | "true"
        | "false"
        | "page"
        | "date";
    aria-describedby?: string;
    aria-description?: string;
    aria-details?: string;
    aria-disabled?: Booleanish;
    aria-dropeffect?:
        | "link"
        | "copy"
        | "move"
        | "none"
        | "execute"
        | "popup";
    aria-errormessage?: string;
    aria-expanded?: Booleanish;
    aria-flowto?: string;
    aria-grabbed?: Booleanish;
    aria-haspopup?:
        | boolean
        | "dialog"
        | "menu"
        | "grid"
        | "true"
        | "false"
        | "listbox"
        | "tree";
    aria-hidden?: Booleanish;
    aria-invalid?:
        | boolean
        | "true"
        | "false"
        | "grammar"
        | "spelling";
    aria-keyshortcuts?: string;
    aria-label?: string;
    aria-labelledby?: string;
    aria-level?: number;
    aria-live?: "off" | "assertive" | "polite";
    aria-modal?: Booleanish;
    aria-multiline?: Booleanish;
    aria-multiselectable?: Booleanish;
    aria-orientation?: "horizontal" | "vertical";
    aria-owns?: string;
    aria-placeholder?: string;
    aria-posinset?: number;
    aria-pressed?:
        | boolean
        | "true"
        | "false"
        | "mixed";
    aria-readonly?: Booleanish;
    aria-relevant?:
        | "text"
        | "additions"
        | "additions removals"
        | "additions text"
        | "all"
        | "removals"
        | "removals additions"
        | "removals text"
        | "text additions"
        | "text removals";
    aria-required?: Booleanish;
    aria-roledescription?: string;
    aria-rowcount?: number;
    aria-rowindex?: number;
    aria-rowindextext?: string;
    aria-rowspan?: number;
    aria-selected?: Booleanish;
    aria-setsize?: number;
    aria-sort?:
        | "none"
        | "ascending"
        | "descending"
        | "other";
    aria-valuemax?: number;
    aria-valuemin?: number;
    aria-valuenow?: number;
    aria-valuetext?: string;
    as?: string;
    async?: boolean;
    autoCapitalize?:
        | string & {}
        | "none"
        | "off"
        | "on"
        | "sentences"
        | "words"
        | "characters";
    autoComplete?: string;
    autoCorrect?: string;
    autoFocus?: boolean;
    autoPlay?: boolean;
    autoSave?: string;
    capture?: boolean | "user" | "environment";
    cellPadding?: string | number;
    cellSpacing?: string | number;
    challenge?: string;
    charSet?: string;
    checked?: boolean;
    children?: ReactNode;
    cite?: string;
    classID?: string;
    className?: string;
    color?: string;
    cols?: number;
    colSpan?: number;
    content?: string;
    contentEditable?: "inherit" | Booleanish | "plaintext-only";
    contextMenu?: string;
    controls?: boolean;
    coords?: string;
    crossOrigin?: CrossOrigin;
    customIcon?: ReactNode;
    dangerouslySetInnerHTML?: {
        __html: string | TrustedHTML;
    };
    data?: string;
    datatype?: string;
    dateTime?: string;
    default?: boolean;
    defaultChecked?: boolean;
    defaultValue?: string | number | readonly string[];
    defer?: boolean;
    dir?: string;
    download?: any;
    draggable?: Booleanish;
    encType?: string;
    enterKeyHint?:
        | "search"
        | "enter"
        | "done"
        | "go"
        | "next"
        | "previous"
        | "send";
    expandedProps?: TextInputExpandedObj;
    form?: string;
    formAction?: string;
    formEncType?: string;
    formMethod?: string;
    formNoValidate?: boolean;
    formTarget?: string;
    frameBorder?: string | number;
    headers?: string;
    height?: string | number;
    hidden?: boolean;
    high?: number;
    href?: string;
    hrefLang?: string;
    htmlFor?: string;
    httpEquiv?: string;
    id?: string;
    inlist?: any;
    innerRef?: RefObject<any>;
    inputMode?:
        | "search"
        | "text"
        | "none"
        | "tel"
        | "url"
        | "email"
        | "numeric"
        | "decimal";
    integrity?: string;
    is?: string;
    isDisabled?: boolean;
    isExpanded?: boolean;
    isLeftTruncated?: boolean;
    isRequired?: boolean;
    isStartTruncated?: boolean;
    itemID?: string;
    itemProp?: string;
    itemRef?: string;
    itemScope?: boolean;
    itemType?: string;
    key?: Key;
    keyParams?: string;
    keyType?: string;
    kind?: string;
    label?: string;
    lang?: string;
    list?: string;
    loop?: boolean;
    low?: number;
    manifest?: string;
    marginHeight?: number;
    marginWidth?: number;
    max?: string | number;
    maxLength?: number;
    media?: string;
    mediaGroup?: string;
    method?: string;
    min?: string | number;
    minLength?: number;
    multiple?: boolean;
    muted?: boolean;
    name?: string;
    nonce?: string;
    noValidate?: boolean;
    onAbort?: ReactEventHandler<HTMLInputElement>;
    onAbortCapture?: ReactEventHandler<HTMLInputElement>;
    onAnimationEnd?: AnimationEventHandler<HTMLInputElement>;
    onAnimationEndCapture?: AnimationEventHandler<HTMLInputElement>;
    onAnimationIteration?: AnimationEventHandler<HTMLInputElement>;
    onAnimationIterationCapture?: AnimationEventHandler<HTMLInputElement>;
    onAnimationStart?: AnimationEventHandler<HTMLInputElement>;
    onAnimationStartCapture?: AnimationEventHandler<HTMLInputElement>;
    onAuxClick?: MouseEventHandler<HTMLInputElement>;
    onAuxClickCapture?: MouseEventHandler<HTMLInputElement>;
    onBeforeInput?: FormEventHandler<HTMLInputElement>;
    onBeforeInputCapture?: FormEventHandler<HTMLInputElement>;
    onBlur?: ((event?: any) => void);
    onBlurCapture?: FocusEventHandler<HTMLInputElement>;
    onCanPlay?: ReactEventHandler<HTMLInputElement>;
    onCanPlayCapture?: ReactEventHandler<HTMLInputElement>;
    onCanPlayThrough?: ReactEventHandler<HTMLInputElement>;
    onCanPlayThroughCapture?: ReactEventHandler<HTMLInputElement>;
    onChange?: ((event: FormEvent<HTMLInputElement>, value: string) => void);
    onChangeCapture?: FormEventHandler<HTMLInputElement>;
    onClick?: MouseEventHandler<HTMLInputElement>;
    onClickCapture?: MouseEventHandler<HTMLInputElement>;
    onCompositionEnd?: CompositionEventHandler<HTMLInputElement>;
    onCompositionEndCapture?: CompositionEventHandler<HTMLInputElement>;
    onCompositionStart?: CompositionEventHandler<HTMLInputElement>;
    onCompositionStartCapture?: CompositionEventHandler<HTMLInputElement>;
    onCompositionUpdate?: CompositionEventHandler<HTMLInputElement>;
    onCompositionUpdateCapture?: CompositionEventHandler<HTMLInputElement>;
    onContextMenu?: MouseEventHandler<HTMLInputElement>;
    onContextMenuCapture?: MouseEventHandler<HTMLInputElement>;
    onCopy?: ClipboardEventHandler<HTMLInputElement>;
    onCopyCapture?: ClipboardEventHandler<HTMLInputElement>;
    onCut?: ClipboardEventHandler<HTMLInputElement>;
    onCutCapture?: ClipboardEventHandler<HTMLInputElement>;
    onDoubleClick?: MouseEventHandler<HTMLInputElement>;
    onDoubleClickCapture?: MouseEventHandler<HTMLInputElement>;
    onDrag?: DragEventHandler<HTMLInputElement>;
    onDragCapture?: DragEventHandler<HTMLInputElement>;
    onDragEnd?: DragEventHandler<HTMLInputElement>;
    onDragEndCapture?: DragEventHandler<HTMLInputElement>;
    onDragEnter?: DragEventHandler<HTMLInputElement>;
    onDragEnterCapture?: DragEventHandler<HTMLInputElement>;
    onDragExit?: DragEventHandler<HTMLInputElement>;
    onDragExitCapture?: DragEventHandler<HTMLInputElement>;
    onDragLeave?: DragEventHandler<HTMLInputElement>;
    onDragLeaveCapture?: DragEventHandler<HTMLInputElement>;
    onDragOver?: DragEventHandler<HTMLInputElement>;
    onDragOverCapture?: DragEventHandler<HTMLInputElement>;
    onDragStart?: DragEventHandler<HTMLInputElement>;
    onDragStartCapture?: DragEventHandler<HTMLInputElement>;
    onDrop?: DragEventHandler<HTMLInputElement>;
    onDropCapture?: DragEventHandler<HTMLInputElement>;
    onDurationChange?: ReactEventHandler<HTMLInputElement>;
    onDurationChangeCapture?: ReactEventHandler<HTMLInputElement>;
    onEmptied?: ReactEventHandler<HTMLInputElement>;
    onEmptiedCapture?: ReactEventHandler<HTMLInputElement>;
    onEncrypted?: ReactEventHandler<HTMLInputElement>;
    onEncryptedCapture?: ReactEventHandler<HTMLInputElement>;
    onEnded?: ReactEventHandler<HTMLInputElement>;
    onEndedCapture?: ReactEventHandler<HTMLInputElement>;
    onError?: ReactEventHandler<HTMLInputElement>;
    onErrorCapture?: ReactEventHandler<HTMLInputElement>;
    onFocus?: ((event?: any) => void);
    onFocusCapture?: FocusEventHandler<HTMLInputElement>;
    onGotPointerCapture?: PointerEventHandler<HTMLInputElement>;
    onGotPointerCaptureCapture?: PointerEventHandler<HTMLInputElement>;
    onInput?: FormEventHandler<HTMLInputElement>;
    onInputCapture?: FormEventHandler<HTMLInputElement>;
    onInvalid?: FormEventHandler<HTMLInputElement>;
    onInvalidCapture?: FormEventHandler<HTMLInputElement>;
    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
    onKeyDownCapture?: KeyboardEventHandler<HTMLInputElement>;
    onKeyPress?: KeyboardEventHandler<HTMLInputElement>;
    onKeyPressCapture?: KeyboardEventHandler<HTMLInputElement>;
    onKeyUp?: KeyboardEventHandler<HTMLInputElement>;
    onKeyUpCapture?: KeyboardEventHandler<HTMLInputElement>;
    onLoad?: ReactEventHandler<HTMLInputElement>;
    onLoadCapture?: ReactEventHandler<HTMLInputElement>;
    onLoadedData?: ReactEventHandler<HTMLInputElement>;
    onLoadedDataCapture?: ReactEventHandler<HTMLInputElement>;
    onLoadedMetadata?: ReactEventHandler<HTMLInputElement>;
    onLoadedMetadataCapture?: ReactEventHandler<HTMLInputElement>;
    onLoadStart?: ReactEventHandler<HTMLInputElement>;
    onLoadStartCapture?: ReactEventHandler<HTMLInputElement>;
    onLostPointerCapture?: PointerEventHandler<HTMLInputElement>;
    onLostPointerCaptureCapture?: PointerEventHandler<HTMLInputElement>;
    onMouseDown?: MouseEventHandler<HTMLInputElement>;
    onMouseDownCapture?: MouseEventHandler<HTMLInputElement>;
    onMouseEnter?: MouseEventHandler<HTMLInputElement>;
    onMouseLeave?: MouseEventHandler<HTMLInputElement>;
    onMouseMove?: MouseEventHandler<HTMLInputElement>;
    onMouseMoveCapture?: MouseEventHandler<HTMLInputElement>;
    onMouseOut?: MouseEventHandler<HTMLInputElement>;
    onMouseOutCapture?: MouseEventHandler<HTMLInputElement>;
    onMouseOver?: MouseEventHandler<HTMLInputElement>;
    onMouseOverCapture?: MouseEventHandler<HTMLInputElement>;
    onMouseUp?: MouseEventHandler<HTMLInputElement>;
    onMouseUpCapture?: MouseEventHandler<HTMLInputElement>;
    onPaste?: ClipboardEventHandler<HTMLInputElement>;
    onPasteCapture?: ClipboardEventHandler<HTMLInputElement>;
    onPause?: ReactEventHandler<HTMLInputElement>;
    onPauseCapture?: ReactEventHandler<HTMLInputElement>;
    onPlay?: ReactEventHandler<HTMLInputElement>;
    onPlayCapture?: ReactEventHandler<HTMLInputElement>;
    onPlaying?: ReactEventHandler<HTMLInputElement>;
    onPlayingCapture?: ReactEventHandler<HTMLInputElement>;
    onPointerCancel?: PointerEventHandler<HTMLInputElement>;
    onPointerCancelCapture?: PointerEventHandler<HTMLInputElement>;
    onPointerDown?: PointerEventHandler<HTMLInputElement>;
    onPointerDownCapture?: PointerEventHandler<HTMLInputElement>;
    onPointerEnter?: PointerEventHandler<HTMLInputElement>;
    onPointerLeave?: PointerEventHandler<HTMLInputElement>;
    onPointerMove?: PointerEventHandler<HTMLInputElement>;
    onPointerMoveCapture?: PointerEventHandler<HTMLInputElement>;
    onPointerOut?: PointerEventHandler<HTMLInputElement>;
    onPointerOutCapture?: PointerEventHandler<HTMLInputElement>;
    onPointerOver?: PointerEventHandler<HTMLInputElement>;
    onPointerOverCapture?: PointerEventHandler<HTMLInputElement>;
    onPointerUp?: PointerEventHandler<HTMLInputElement>;
    onPointerUpCapture?: PointerEventHandler<HTMLInputElement>;
    onProgress?: ReactEventHandler<HTMLInputElement>;
    onProgressCapture?: ReactEventHandler<HTMLInputElement>;
    onRateChange?: ReactEventHandler<HTMLInputElement>;
    onRateChangeCapture?: ReactEventHandler<HTMLInputElement>;
    onReset?: FormEventHandler<HTMLInputElement>;
    onResetCapture?: FormEventHandler<HTMLInputElement>;
    onResize?: ReactEventHandler<HTMLInputElement>;
    onResizeCapture?: ReactEventHandler<HTMLInputElement>;
    onScroll?: UIEventHandler<HTMLInputElement>;
    onScrollCapture?: UIEventHandler<HTMLInputElement>;
    onSeeked?: ReactEventHandler<HTMLInputElement>;
    onSeekedCapture?: ReactEventHandler<HTMLInputElement>;
    onSeeking?: ReactEventHandler<HTMLInputElement>;
    onSeekingCapture?: ReactEventHandler<HTMLInputElement>;
    onSelect?: ReactEventHandler<HTMLInputElement>;
    onSelectCapture?: ReactEventHandler<HTMLInputElement>;
    onStalled?: ReactEventHandler<HTMLInputElement>;
    onStalledCapture?: ReactEventHandler<HTMLInputElement>;
    onSubmit?: FormEventHandler<HTMLInputElement>;
    onSubmitCapture?: FormEventHandler<HTMLInputElement>;
    onSuspend?: ReactEventHandler<HTMLInputElement>;
    onSuspendCapture?: ReactEventHandler<HTMLInputElement>;
    onTimeUpdate?: ReactEventHandler<HTMLInputElement>;
    onTimeUpdateCapture?: ReactEventHandler<HTMLInputElement>;
    onTouchCancel?: TouchEventHandler<HTMLInputElement>;
    onTouchCancelCapture?: TouchEventHandler<HTMLInputElement>;
    onTouchEnd?: TouchEventHandler<HTMLInputElement>;
    onTouchEndCapture?: TouchEventHandler<HTMLInputElement>;
    onTouchMove?: TouchEventHandler<HTMLInputElement>;
    onTouchMoveCapture?: TouchEventHandler<HTMLInputElement>;
    onTouchStart?: TouchEventHandler<HTMLInputElement>;
    onTouchStartCapture?: TouchEventHandler<HTMLInputElement>;
    onTransitionEnd?: TransitionEventHandler<HTMLInputElement>;
    onTransitionEndCapture?: TransitionEventHandler<HTMLInputElement>;
    onVolumeChange?: ReactEventHandler<HTMLInputElement>;
    onVolumeChangeCapture?: ReactEventHandler<HTMLInputElement>;
    onWaiting?: ReactEventHandler<HTMLInputElement>;
    onWaitingCapture?: ReactEventHandler<HTMLInputElement>;
    onWheel?: WheelEventHandler<HTMLInputElement>;
    onWheelCapture?: WheelEventHandler<HTMLInputElement>;
    open?: boolean;
    optimum?: number;
    ouiaId?: string | number;
    ouiaSafe?: boolean;
    pattern?: string;
    placeholder?: string;
    playsInline?: boolean;
    poster?: string;
    prefix?: string;
    preload?: string;
    property?: string;
    radioGroup?: string;
    readOnly?: boolean;
    readOnlyVariant?: "default" | "plain";
    rel?: string;
    required?: boolean;
    resource?: string;
    results?: number;
    rev?: string;
    reversed?: boolean;
    role?: AriaRole;
    rows?: number;
    rowSpan?: number;
    sandbox?: string;
    scope?: string;
    scoped?: boolean;
    scrolling?: string;
    seamless?: boolean;
    security?: string;
    selected?: boolean;
    shape?: string;
    size?: number;
    sizes?: string;
    slot?: string;
    span?: number;
    spellCheck?: Booleanish;
    src?: string;
    srcDoc?: string;
    srcLang?: string;
    srcSet?: string;
    start?: number;
    step?: string | number;
    style?: CSSProperties;
    summary?: string;
    suppressContentEditableWarning?: boolean;
    suppressHydrationWarning?: boolean;
    tabIndex?: number;
    target?: string;
    title?: string;
    translate?: "yes" | "no";
    type?:
        | "number"
        | "search"
        | "time"
        | "text"
        | "tel"
        | "url"
        | "email"
        | "date"
        | "datetime-local"
        | "month"
        | "password";
    typeof?: string;
    unselectable?: "off" | "on";
    useMap?: string;
    validated?:
        | "default"
        | "success"
        | "warning"
        | "error";
    value?: string | number;
    vocab?: string;
    width?: string | number;
    wmode?: string;
    wrap?: string;
}

Hierarchy (view full)

  • Omit<React.HTMLProps<HTMLInputElement>,
        | "onChange"
        | "onFocus"
        | "onBlur"
        | "disabled"
        | "ref">
  • OUIAProps
    • TextInputProps

Properties

about? accept? acceptCharset? accessKey? action? allowFullScreen? allowTransparency? alt? aria-activedescendant? aria-atomic? aria-autocomplete? aria-braillelabel? aria-brailleroledescription? aria-busy? aria-checked? aria-colcount? aria-colindex? aria-colindextext? aria-colspan? aria-controls? aria-current? aria-describedby? aria-description? aria-details? aria-disabled? aria-dropeffect? aria-errormessage? aria-expanded? aria-flowto? aria-grabbed? aria-haspopup? aria-hidden? aria-invalid? aria-keyshortcuts? aria-label? aria-labelledby? aria-level? aria-live? aria-modal? aria-multiline? aria-multiselectable? aria-orientation? aria-owns? aria-placeholder? aria-posinset? aria-pressed? aria-readonly? aria-relevant? aria-required? aria-roledescription? aria-rowcount? aria-rowindex? aria-rowindextext? aria-rowspan? aria-selected? aria-setsize? aria-sort? aria-valuemax? aria-valuemin? aria-valuenow? aria-valuetext? as? async? autoCapitalize? autoComplete? autoCorrect? autoFocus? autoPlay? autoSave? capture? cellPadding? cellSpacing? challenge? charSet? checked? children? cite? classID? className? color? cols? colSpan? content? contentEditable? contextMenu? controls? coords? crossOrigin? customIcon? dangerouslySetInnerHTML? data? datatype? dateTime? default? defaultChecked? defaultValue? defer? dir? download? draggable? encType? enterKeyHint? expandedProps? form? formAction? formEncType? formMethod? formNoValidate? formTarget? frameBorder? headers? height? hidden? high? href? hrefLang? htmlFor? httpEquiv? id? inlist? innerRef? inputMode? integrity? is? isDisabled? isExpanded? isLeftTruncated? isRequired? isStartTruncated? itemID? itemProp? itemRef? itemScope? itemType? key? keyParams? keyType? kind? label? lang? list? loop? low? manifest? marginHeight? marginWidth? max? maxLength? media? mediaGroup? method? min? minLength? multiple? muted? name? nonce? noValidate? onAbort? onAbortCapture? onAnimationEnd? onAnimationEndCapture? onAnimationIteration? onAnimationIterationCapture? onAnimationStart? onAnimationStartCapture? onAuxClick? onAuxClickCapture? onBeforeInput? onBeforeInputCapture? onBlur? onBlurCapture? onCanPlay? onCanPlayCapture? onCanPlayThrough? onCanPlayThroughCapture? onChange? onChangeCapture? onClick? onClickCapture? onCompositionEnd? onCompositionEndCapture? onCompositionStart? onCompositionStartCapture? onCompositionUpdate? onCompositionUpdateCapture? onContextMenu? onContextMenuCapture? onCopy? onCopyCapture? onCut? onCutCapture? onDoubleClick? onDoubleClickCapture? onDrag? onDragCapture? onDragEnd? onDragEndCapture? onDragEnter? onDragEnterCapture? onDragExit? onDragExitCapture? onDragLeave? onDragLeaveCapture? onDragOver? onDragOverCapture? onDragStart? onDragStartCapture? onDrop? onDropCapture? onDurationChange? onDurationChangeCapture? onEmptied? onEmptiedCapture? onEncrypted? onEncryptedCapture? onEnded? onEndedCapture? onError? onErrorCapture? onFocus? onFocusCapture? onGotPointerCapture? onGotPointerCaptureCapture? onInput? onInputCapture? onInvalid? onInvalidCapture? onKeyDown? onKeyDownCapture? onKeyPress? onKeyPressCapture? onKeyUp? onKeyUpCapture? onLoad? onLoadCapture? onLoadedData? onLoadedDataCapture? onLoadedMetadata? onLoadedMetadataCapture? onLoadStart? onLoadStartCapture? onLostPointerCapture? onLostPointerCaptureCapture? onMouseDown? onMouseDownCapture? onMouseEnter? onMouseLeave? onMouseMove? onMouseMoveCapture? onMouseOut? onMouseOutCapture? onMouseOver? onMouseOverCapture? onMouseUp? onMouseUpCapture? onPaste? onPasteCapture? onPause? onPauseCapture? onPlay? onPlayCapture? onPlaying? onPlayingCapture? onPointerCancel? onPointerCancelCapture? onPointerDown? onPointerDownCapture? onPointerEnter? onPointerLeave? onPointerMove? onPointerMoveCapture? onPointerOut? onPointerOutCapture? onPointerOver? onPointerOverCapture? onPointerUp? onPointerUpCapture? onProgress? onProgressCapture? onRateChange? onRateChangeCapture? onReset? onResetCapture? onResize? onResizeCapture? onScroll? onScrollCapture? onSeeked? onSeekedCapture? onSeeking? onSeekingCapture? onSelect? onSelectCapture? onStalled? onStalledCapture? onSubmit? onSubmitCapture? onSuspend? onSuspendCapture? onTimeUpdate? onTimeUpdateCapture? onTouchCancel? onTouchCancelCapture? onTouchEnd? onTouchEndCapture? onTouchMove? onTouchMoveCapture? onTouchStart? onTouchStartCapture? onTransitionEnd? onTransitionEndCapture? onVolumeChange? onVolumeChangeCapture? onWaiting? onWaitingCapture? onWheel? onWheelCapture? open? optimum? ouiaId? ouiaSafe? pattern? placeholder? playsInline? poster? prefix? preload? property? radioGroup? readOnly? readOnlyVariant? rel? required? resource? results? rev? reversed? role? rows? rowSpan? sandbox? scope? scoped? scrolling? seamless? security? selected? shape? size? sizes? slot? span? spellCheck? src? srcDoc? srcLang? srcSet? start? step? style? summary? suppressContentEditableWarning? suppressHydrationWarning? tabIndex? target? title? translate? type? typeof? unselectable? useMap? validated? value? vocab? width? wmode? wrap?

Properties

Optionalabout

about?: string

Optionalaccept

accept?: string

OptionalacceptCharset

acceptCharset?: string

OptionalaccessKey

accessKey?: string

Optionalaction

action?: string

OptionalallowFullScreen

allowFullScreen?: boolean

OptionalallowTransparency

allowTransparency?: boolean

Optionalalt

alt?: string

Optionalaria-activedescendant

aria-activedescendant?: string

Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application.

Optionalaria-atomic

aria-atomic?: Booleanish

Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute.

Optionalaria-autocomplete

aria-autocomplete?:
    | "list"
    | "inline"
    | "none"
    | "both"

Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be presented if they are made.

Optionalaria-braillelabel

aria-braillelabel?: string

Defines a string value that labels the current element, which is intended to be converted into Braille.

See

aria-label.

Optionalaria-brailleroledescription

aria-brailleroledescription?: string

Defines a human-readable, author-localized abbreviated description for the role of an element, which is intended to be converted into Braille.

See

aria-roledescription.

Optionalaria-busy

aria-busy?: Booleanish

Optionalaria-checked

aria-checked?:
    | boolean
    | "true"
    | "false"
    | "mixed"

Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.

See

  • aria-pressed
  • aria-selected.

Optionalaria-colcount

aria-colcount?: number

Defines the total number of columns in a table, grid, or treegrid.

See

aria-colindex.

Optionalaria-colindex

aria-colindex?: number

Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.

See

  • aria-colcount
  • aria-colspan.

Optionalaria-colindextext

aria-colindextext?: string

Defines a human readable text alternative of aria-colindex.

See

aria-rowindextext.

Optionalaria-colspan

aria-colspan?: number

Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.

See

  • aria-colindex
  • aria-rowspan.

Optionalaria-controls

aria-controls?: string

Identifies the element (or elements) whose contents or presence are controlled by the current element.

See

aria-owns.

Optionalaria-current

aria-current?:
    | boolean
    | "step"
    | "time"
    | "location"
    | "true"
    | "false"
    | "page"
    | "date"

Indicates the element that represents the current item within a container or set of related elements.

Optionalaria-describedby

aria-describedby?: string

Identifies the element (or elements) that describes the object.

See

aria-labelledby

Optionalaria-description

aria-description?: string

Defines a string value that describes or annotates the current element.

See

related aria-describedby.

Optionalaria-details

aria-details?: string

Identifies the element that provides a detailed, extended description for the object.

See

aria-describedby.

Optionalaria-disabled

aria-disabled?: Booleanish

Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.

See

  • aria-hidden
  • aria-readonly.

Optionalaria-dropeffect

aria-dropeffect?:
    | "link"
    | "copy"
    | "move"
    | "none"
    | "execute"
    | "popup"

Indicates what functions can be performed when a dragged object is released on the drop target.

Deprecated

in ARIA 1.1

Optionalaria-errormessage

aria-errormessage?: string

Identifies the element that provides an error message for the object.

See

  • aria-invalid
  • aria-describedby.

Optionalaria-expanded

aria-expanded?: Booleanish

Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed.

Optionalaria-flowto

aria-flowto?: string

Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion, allows assistive technology to override the general default of reading in document source order.

Optionalaria-grabbed

aria-grabbed?: Booleanish

Indicates an element's "grabbed" state in a drag-and-drop operation.

Deprecated

in ARIA 1.1

Optionalaria-haspopup

aria-haspopup?:
    | boolean
    | "dialog"
    | "menu"
    | "grid"
    | "true"
    | "false"
    | "listbox"
    | "tree"

Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element.

Optionalaria-hidden

aria-hidden?: Booleanish

Indicates whether the element is exposed to an accessibility API.

See

aria-disabled.

Optionalaria-invalid

aria-invalid?:
    | boolean
    | "true"
    | "false"
    | "grammar"
    | "spelling"

Indicates the entered value does not conform to the format expected by the application.

See

aria-errormessage.

Optionalaria-keyshortcuts

aria-keyshortcuts?: string

Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element.

Optionalaria-label

aria-label?: string

Aria-label. The text input requires an associated id or aria-label.

Optionalaria-labelledby

aria-labelledby?: string

Identifies the element (or elements) that labels the current element.

See

aria-describedby.

Optionalaria-level

aria-level?: number

Defines the hierarchical level of an element within a structure.

Optionalaria-live

aria-live?: "off" | "assertive" | "polite"

Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region.

Optionalaria-modal

aria-modal?: Booleanish

Indicates whether an element is modal when displayed.

Optionalaria-multiline

aria-multiline?: Booleanish

Indicates whether a text box accepts multiple lines of input or only a single line.

Optionalaria-multiselectable

aria-multiselectable?: Booleanish

Indicates that the user may select more than one item from the current selectable descendants.

Optionalaria-orientation

aria-orientation?: "horizontal" | "vertical"

Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous.

Optionalaria-owns

aria-owns?: string

Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship between DOM elements where the DOM hierarchy cannot be used to represent the relationship.

See

aria-controls.

Optionalaria-placeholder

aria-placeholder?: string

Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value. A hint could be a sample value or a brief description of the expected format.

Optionalaria-posinset

aria-posinset?: number

Defines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.

See

aria-setsize.

Optionalaria-pressed

aria-pressed?:
    | boolean
    | "true"
    | "false"
    | "mixed"

Indicates the current "pressed" state of toggle buttons.

See

  • aria-checked
  • aria-selected.

Optionalaria-readonly

aria-readonly?: Booleanish

Indicates that the element is not editable, but is otherwise operable.

See

aria-disabled.

Optionalaria-relevant

aria-relevant?:
    | "text"
    | "additions"
    | "additions removals"
    | "additions text"
    | "all"
    | "removals"
    | "removals additions"
    | "removals text"
    | "text additions"
    | "text removals"

Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.

See

aria-atomic.

Optionalaria-required

aria-required?: Booleanish

Indicates that user input is required on the element before a form may be submitted.

Optionalaria-roledescription

aria-roledescription?: string

Defines a human-readable, author-localized description for the role of an element.

Optionalaria-rowcount

aria-rowcount?: number

Defines the total number of rows in a table, grid, or treegrid.

See

aria-rowindex.

Optionalaria-rowindex

aria-rowindex?: number

Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.

See

  • aria-rowcount
  • aria-rowspan.

Optionalaria-rowindextext

aria-rowindextext?: string

Defines a human readable text alternative of aria-rowindex.

See

aria-colindextext.

Optionalaria-rowspan

aria-rowspan?: number

Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.

See

  • aria-rowindex
  • aria-colspan.

Optionalaria-selected

aria-selected?: Booleanish

Indicates the current "selected" state of various widgets.

See

  • aria-checked
  • aria-pressed.

Optionalaria-setsize

aria-setsize?: number

Defines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.

See

aria-posinset.

Optionalaria-sort

aria-sort?:
    | "none"
    | "ascending"
    | "descending"
    | "other"

Indicates if items in a table or grid are sorted in ascending or descending order.

Optionalaria-valuemax

aria-valuemax?: number

Defines the maximum allowed value for a range widget.

Optionalaria-valuemin

aria-valuemin?: number

Defines the minimum allowed value for a range widget.

Optionalaria-valuenow

aria-valuenow?: number

Defines the current value for a range widget.

See

aria-valuetext.

Optionalaria-valuetext

aria-valuetext?: string

Defines the human readable text alternative of aria-valuenow for a range widget.

Optionalas

as?: string

Optionalasync

async?: boolean

OptionalautoCapitalize

autoCapitalize?:
    | string & {}
    | "none"
    | "off"
    | "on"
    | "sentences"
    | "words"
    | "characters"

OptionalautoComplete

autoComplete?: string

OptionalautoCorrect

autoCorrect?: string

OptionalautoFocus

autoFocus?: boolean

OptionalautoPlay

autoPlay?: boolean

OptionalautoSave

autoSave?: string

Optionalcapture

capture?: boolean | "user" | "environment"

OptionalcellPadding

cellPadding?: string | number

OptionalcellSpacing

cellSpacing?: string | number

Optionalchallenge

challenge?: string

OptionalcharSet

charSet?: string

Optionalchecked

checked?: boolean

Optionalchildren

children?: ReactNode

Optionalcite

cite?: string

OptionalclassID

classID?: string

OptionalclassName

className?: string

Additional classes added to the text input.

Optionalcolor

color?: string

Optionalcols

cols?: number

OptionalcolSpan

colSpan?: number

Optionalcontent

content?: string

OptionalcontentEditable

contentEditable?: "inherit" | Booleanish | "plaintext-only"

OptionalcontextMenu

contextMenu?: string

Optionalcontrols

controls?: boolean

Optionalcoords

coords?: string

OptionalcrossOrigin

crossOrigin?: CrossOrigin

OptionalcustomIcon

customIcon?: ReactNode

Custom icon to render. If the validated prop is also passed, this will render an icon in addition to a validated icon.

OptionaldangerouslySetInnerHTML

dangerouslySetInnerHTML?: {
    __html: string | TrustedHTML;
}

Optionaldata

data?: string

Optionaldatatype

datatype?: string

OptionaldateTime

dateTime?: string

Optionaldefault

default?: boolean

OptionaldefaultChecked

defaultChecked?: boolean

OptionaldefaultValue

defaultValue?: string | number | readonly string[]

Optionaldefer

defer?: boolean

Optionaldir

dir?: string

Optionaldownload

download?: any

Optionaldraggable

draggable?: Booleanish

OptionalencType

encType?: string

OptionalenterKeyHint

enterKeyHint?:
    | "search"
    | "enter"
    | "done"
    | "go"
    | "next"
    | "previous"
    | "send"

OptionalexpandedProps

expandedProps?: TextInputExpandedObj

Prop to apply expanded styling to the text input and link it to the element it is controlling. This should be used when the input controls a menu and that menu is expandable.

Optionalform

form?: string

OptionalformAction

formAction?: string

OptionalformEncType

formEncType?: string

OptionalformMethod

formMethod?: string

OptionalformNoValidate

formNoValidate?: boolean

OptionalformTarget

formTarget?: string

OptionalframeBorder

frameBorder?: string | number

Optionalheaders

headers?: string

Optionalheight

height?: string | number

Optionalhidden

hidden?: boolean

Optionalhigh

high?: number

Optionalhref

href?: string

OptionalhrefLang

hrefLang?: string

OptionalhtmlFor

htmlFor?: string

OptionalhttpEquiv

httpEquiv?: string

Optionalid

id?: string

Optionalinlist

inlist?: any

OptionalinnerRef

innerRef?: RefObject<any>

Hide

A reference object to attach to the text input box.

OptionalinputMode

inputMode?:
    | "search"
    | "text"
    | "none"
    | "tel"
    | "url"
    | "email"
    | "numeric"
    | "decimal"

Hints at the type of data that might be entered by the user while editing the element or its contents

See

https://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute

Optionalintegrity

integrity?: string

Optionalis

is?: string

Specify that a standard HTML element should behave like a defined custom built-in element

See

https://html.spec.whatwg.org/multipage/custom-elements.html#attr-is

OptionalisDisabled

isDisabled?: boolean

Flag to show if the text input is disabled.

OptionalisExpanded

isExpanded?: boolean

Deprecated

Flag to apply expanded styling. expandedProps should now be used instead.

OptionalisLeftTruncated

isLeftTruncated?: boolean

Deprecated

Use isStartTruncated instead. Trim text at start

OptionalisRequired

isRequired?: boolean

Flag indicating whether the input is required

OptionalisStartTruncated

isStartTruncated?: boolean

Trim text at start

OptionalitemID

itemID?: string

OptionalitemProp

itemProp?: string

OptionalitemRef

itemRef?: string

OptionalitemScope

itemScope?: boolean

OptionalitemType

itemType?: string

Optionalkey

key?: Key

OptionalkeyParams

keyParams?: string

OptionalkeyType

keyType?: string

Optionalkind

kind?: string

Optionallabel

label?: string

Optionallang

lang?: string

Optionallist

list?: string

Optionalloop

loop?: boolean

Optionallow

low?: number

Optionalmanifest

manifest?: string

OptionalmarginHeight

marginHeight?: number

OptionalmarginWidth

marginWidth?: number

Optionalmax

max?: string | number

OptionalmaxLength

maxLength?: number

Optionalmedia

media?: string

OptionalmediaGroup

mediaGroup?: string

Optionalmethod

method?: string

Optionalmin

min?: string | number

OptionalminLength

minLength?: number

Optionalmultiple

multiple?: boolean

Optionalmuted

muted?: boolean

Optionalname

name?: string

Optionalnonce

nonce?: string

OptionalnoValidate

noValidate?: boolean

OptionalonAbort

onAbort?: ReactEventHandler<HTMLInputElement>

OptionalonAbortCapture

onAbortCapture?: ReactEventHandler<HTMLInputElement>

OptionalonAnimationEnd

onAnimationEnd?: AnimationEventHandler<HTMLInputElement>

OptionalonAnimationEndCapture

onAnimationEndCapture?: AnimationEventHandler<HTMLInputElement>

OptionalonAnimationIteration

onAnimationIteration?: AnimationEventHandler<HTMLInputElement>

OptionalonAnimationIterationCapture

onAnimationIterationCapture?: AnimationEventHandler<HTMLInputElement>

OptionalonAnimationStart

onAnimationStart?: AnimationEventHandler<HTMLInputElement>

OptionalonAnimationStartCapture

onAnimationStartCapture?: AnimationEventHandler<HTMLInputElement>

OptionalonAuxClick

onAuxClick?: MouseEventHandler<HTMLInputElement>

OptionalonAuxClickCapture

onAuxClickCapture?: MouseEventHandler<HTMLInputElement>

OptionalonBeforeInput

onBeforeInput?: FormEventHandler<HTMLInputElement>

OptionalonBeforeInputCapture

onBeforeInputCapture?: FormEventHandler<HTMLInputElement>

OptionalonBlur

onBlur?: ((event?: any) => void)

Callback function when text input is blurred (focus leaves)

OptionalonBlurCapture

onBlurCapture?: FocusEventHandler<HTMLInputElement>

OptionalonCanPlay

onCanPlay?: ReactEventHandler<HTMLInputElement>

OptionalonCanPlayCapture

onCanPlayCapture?: ReactEventHandler<HTMLInputElement>

OptionalonCanPlayThrough

onCanPlayThrough?: ReactEventHandler<HTMLInputElement>

OptionalonCanPlayThroughCapture

onCanPlayThroughCapture?: ReactEventHandler<HTMLInputElement>

OptionalonChange

onChange?: ((event: FormEvent<HTMLInputElement>, value: string) => void)

A callback for when the text input value changes.

OptionalonChangeCapture

onChangeCapture?: FormEventHandler<HTMLInputElement>

OptionalonClick

onClick?: MouseEventHandler<HTMLInputElement>

OptionalonClickCapture

onClickCapture?: MouseEventHandler<HTMLInputElement>

OptionalonCompositionEnd

onCompositionEnd?: CompositionEventHandler<HTMLInputElement>

OptionalonCompositionEndCapture

onCompositionEndCapture?: CompositionEventHandler<HTMLInputElement>

OptionalonCompositionStart

onCompositionStart?: CompositionEventHandler<HTMLInputElement>

OptionalonCompositionStartCapture

onCompositionStartCapture?: CompositionEventHandler<HTMLInputElement>

OptionalonCompositionUpdate

onCompositionUpdate?: CompositionEventHandler<HTMLInputElement>

OptionalonCompositionUpdateCapture

onCompositionUpdateCapture?: CompositionEventHandler<HTMLInputElement>

OptionalonContextMenu

onContextMenu?: MouseEventHandler<HTMLInputElement>

OptionalonContextMenuCapture

onContextMenuCapture?: MouseEventHandler<HTMLInputElement>

OptionalonCopy

onCopy?: ClipboardEventHandler<HTMLInputElement>

OptionalonCopyCapture

onCopyCapture?: ClipboardEventHandler<HTMLInputElement>

OptionalonCut

onCut?: ClipboardEventHandler<HTMLInputElement>

OptionalonCutCapture

onCutCapture?: ClipboardEventHandler<HTMLInputElement>

OptionalonDoubleClick

onDoubleClick?: MouseEventHandler<HTMLInputElement>

OptionalonDoubleClickCapture

onDoubleClickCapture?: MouseEventHandler<HTMLInputElement>

OptionalonDrag

onDrag?: DragEventHandler<HTMLInputElement>

OptionalonDragCapture

onDragCapture?: DragEventHandler<HTMLInputElement>

OptionalonDragEnd

onDragEnd?: DragEventHandler<HTMLInputElement>

OptionalonDragEndCapture

onDragEndCapture?: DragEventHandler<HTMLInputElement>

OptionalonDragEnter

onDragEnter?: DragEventHandler<HTMLInputElement>

OptionalonDragEnterCapture

onDragEnterCapture?: DragEventHandler<HTMLInputElement>

OptionalonDragExit

onDragExit?: DragEventHandler<HTMLInputElement>

OptionalonDragExitCapture

onDragExitCapture?: DragEventHandler<HTMLInputElement>

OptionalonDragLeave

onDragLeave?: DragEventHandler<HTMLInputElement>

OptionalonDragLeaveCapture

onDragLeaveCapture?: DragEventHandler<HTMLInputElement>

OptionalonDragOver

onDragOver?: DragEventHandler<HTMLInputElement>

OptionalonDragOverCapture

onDragOverCapture?: DragEventHandler<HTMLInputElement>

OptionalonDragStart

onDragStart?: DragEventHandler<HTMLInputElement>

OptionalonDragStartCapture

onDragStartCapture?: DragEventHandler<HTMLInputElement>

OptionalonDrop

onDrop?: DragEventHandler<HTMLInputElement>

OptionalonDropCapture

onDropCapture?: DragEventHandler<HTMLInputElement>

OptionalonDurationChange

onDurationChange?: ReactEventHandler<HTMLInputElement>

OptionalonDurationChangeCapture

onDurationChangeCapture?: ReactEventHandler<HTMLInputElement>

OptionalonEmptied

onEmptied?: ReactEventHandler<HTMLInputElement>

OptionalonEmptiedCapture

onEmptiedCapture?: ReactEventHandler<HTMLInputElement>

OptionalonEncrypted

onEncrypted?: ReactEventHandler<HTMLInputElement>

OptionalonEncryptedCapture

onEncryptedCapture?: ReactEventHandler<HTMLInputElement>

OptionalonEnded

onEnded?: ReactEventHandler<HTMLInputElement>

OptionalonEndedCapture

onEndedCapture?: ReactEventHandler<HTMLInputElement>

OptionalonError

onError?: ReactEventHandler<HTMLInputElement>

OptionalonErrorCapture

onErrorCapture?: ReactEventHandler<HTMLInputElement>

OptionalonFocus

onFocus?: ((event?: any) => void)

Callback function when text input is focused

OptionalonFocusCapture

onFocusCapture?: FocusEventHandler<HTMLInputElement>

OptionalonGotPointerCapture

onGotPointerCapture?: PointerEventHandler<HTMLInputElement>

OptionalonGotPointerCaptureCapture

onGotPointerCaptureCapture?: PointerEventHandler<HTMLInputElement>

OptionalonInput

onInput?: FormEventHandler<HTMLInputElement>

OptionalonInputCapture

onInputCapture?: FormEventHandler<HTMLInputElement>

OptionalonInvalid

onInvalid?: FormEventHandler<HTMLInputElement>

OptionalonInvalidCapture

onInvalidCapture?: FormEventHandler<HTMLInputElement>

OptionalonKeyDown

onKeyDown?: KeyboardEventHandler<HTMLInputElement>

OptionalonKeyDownCapture

onKeyDownCapture?: KeyboardEventHandler<HTMLInputElement>

OptionalonKeyPress

onKeyPress?: KeyboardEventHandler<HTMLInputElement>

Deprecated

Use onKeyUp or onKeyDown instead

OptionalonKeyPressCapture

onKeyPressCapture?: KeyboardEventHandler<HTMLInputElement>

Deprecated

Use onKeyUpCapture or onKeyDownCapture instead

OptionalonKeyUp

onKeyUp?: KeyboardEventHandler<HTMLInputElement>

OptionalonKeyUpCapture

onKeyUpCapture?: KeyboardEventHandler<HTMLInputElement>

OptionalonLoad

onLoad?: ReactEventHandler<HTMLInputElement>

OptionalonLoadCapture

onLoadCapture?: ReactEventHandler<HTMLInputElement>

OptionalonLoadedData

onLoadedData?: ReactEventHandler<HTMLInputElement>

OptionalonLoadedDataCapture

onLoadedDataCapture?: ReactEventHandler<HTMLInputElement>

OptionalonLoadedMetadata

onLoadedMetadata?: ReactEventHandler<HTMLInputElement>

OptionalonLoadedMetadataCapture

onLoadedMetadataCapture?: ReactEventHandler<HTMLInputElement>

OptionalonLoadStart

onLoadStart?: ReactEventHandler<HTMLInputElement>

OptionalonLoadStartCapture

onLoadStartCapture?: ReactEventHandler<HTMLInputElement>

OptionalonLostPointerCapture

onLostPointerCapture?: PointerEventHandler<HTMLInputElement>

OptionalonLostPointerCaptureCapture

onLostPointerCaptureCapture?: PointerEventHandler<HTMLInputElement>

OptionalonMouseDown

onMouseDown?: MouseEventHandler<HTMLInputElement>

OptionalonMouseDownCapture

onMouseDownCapture?: MouseEventHandler<HTMLInputElement>

OptionalonMouseEnter

onMouseEnter?: MouseEventHandler<HTMLInputElement>

OptionalonMouseLeave

onMouseLeave?: MouseEventHandler<HTMLInputElement>

OptionalonMouseMove

onMouseMove?: MouseEventHandler<HTMLInputElement>

OptionalonMouseMoveCapture

onMouseMoveCapture?: MouseEventHandler<HTMLInputElement>

OptionalonMouseOut

onMouseOut?: MouseEventHandler<HTMLInputElement>

OptionalonMouseOutCapture

onMouseOutCapture?: MouseEventHandler<HTMLInputElement>

OptionalonMouseOver

onMouseOver?: MouseEventHandler<HTMLInputElement>

OptionalonMouseOverCapture

onMouseOverCapture?: MouseEventHandler<HTMLInputElement>

OptionalonMouseUp

onMouseUp?: MouseEventHandler<HTMLInputElement>

OptionalonMouseUpCapture

onMouseUpCapture?: MouseEventHandler<HTMLInputElement>

OptionalonPaste

onPaste?: ClipboardEventHandler<HTMLInputElement>

OptionalonPasteCapture

onPasteCapture?: ClipboardEventHandler<HTMLInputElement>

OptionalonPause

onPause?: ReactEventHandler<HTMLInputElement>

OptionalonPauseCapture

onPauseCapture?: ReactEventHandler<HTMLInputElement>

OptionalonPlay

onPlay?: ReactEventHandler<HTMLInputElement>

OptionalonPlayCapture

onPlayCapture?: ReactEventHandler<HTMLInputElement>

OptionalonPlaying

onPlaying?: ReactEventHandler<HTMLInputElement>

OptionalonPlayingCapture

onPlayingCapture?: ReactEventHandler<HTMLInputElement>

OptionalonPointerCancel

onPointerCancel?: PointerEventHandler<HTMLInputElement>

OptionalonPointerCancelCapture

onPointerCancelCapture?: PointerEventHandler<HTMLInputElement>

OptionalonPointerDown

onPointerDown?: PointerEventHandler<HTMLInputElement>

OptionalonPointerDownCapture

onPointerDownCapture?: PointerEventHandler<HTMLInputElement>

OptionalonPointerEnter

onPointerEnter?: PointerEventHandler<HTMLInputElement>

OptionalonPointerLeave

onPointerLeave?: PointerEventHandler<HTMLInputElement>

OptionalonPointerMove

onPointerMove?: PointerEventHandler<HTMLInputElement>

OptionalonPointerMoveCapture

onPointerMoveCapture?: PointerEventHandler<HTMLInputElement>

OptionalonPointerOut

onPointerOut?: PointerEventHandler<HTMLInputElement>

OptionalonPointerOutCapture

onPointerOutCapture?: PointerEventHandler<HTMLInputElement>

OptionalonPointerOver

onPointerOver?: PointerEventHandler<HTMLInputElement>

OptionalonPointerOverCapture

onPointerOverCapture?: PointerEventHandler<HTMLInputElement>

OptionalonPointerUp

onPointerUp?: PointerEventHandler<HTMLInputElement>

OptionalonPointerUpCapture

onPointerUpCapture?: PointerEventHandler<HTMLInputElement>

OptionalonProgress

onProgress?: ReactEventHandler<HTMLInputElement>

OptionalonProgressCapture

onProgressCapture?: ReactEventHandler<HTMLInputElement>

OptionalonRateChange

onRateChange?: ReactEventHandler<HTMLInputElement>

OptionalonRateChangeCapture

onRateChangeCapture?: ReactEventHandler<HTMLInputElement>

OptionalonReset

onReset?: FormEventHandler<HTMLInputElement>

OptionalonResetCapture

onResetCapture?: FormEventHandler<HTMLInputElement>

OptionalonResize

onResize?: ReactEventHandler<HTMLInputElement>

OptionalonResizeCapture

onResizeCapture?: ReactEventHandler<HTMLInputElement>

OptionalonScroll

onScroll?: UIEventHandler<HTMLInputElement>

OptionalonScrollCapture

onScrollCapture?: UIEventHandler<HTMLInputElement>

OptionalonSeeked

onSeeked?: ReactEventHandler<HTMLInputElement>

OptionalonSeekedCapture

onSeekedCapture?: ReactEventHandler<HTMLInputElement>

OptionalonSeeking

onSeeking?: ReactEventHandler<HTMLInputElement>

OptionalonSeekingCapture

onSeekingCapture?: ReactEventHandler<HTMLInputElement>

OptionalonSelect

onSelect?: ReactEventHandler<HTMLInputElement>

OptionalonSelectCapture

onSelectCapture?: ReactEventHandler<HTMLInputElement>

OptionalonStalled

onStalled?: ReactEventHandler<HTMLInputElement>

OptionalonStalledCapture

onStalledCapture?: ReactEventHandler<HTMLInputElement>

OptionalonSubmit

onSubmit?: FormEventHandler<HTMLInputElement>

OptionalonSubmitCapture

onSubmitCapture?: FormEventHandler<HTMLInputElement>

OptionalonSuspend

onSuspend?: ReactEventHandler<HTMLInputElement>

OptionalonSuspendCapture

onSuspendCapture?: ReactEventHandler<HTMLInputElement>

OptionalonTimeUpdate

onTimeUpdate?: ReactEventHandler<HTMLInputElement>

OptionalonTimeUpdateCapture

onTimeUpdateCapture?: ReactEventHandler<HTMLInputElement>

OptionalonTouchCancel

onTouchCancel?: TouchEventHandler<HTMLInputElement>

OptionalonTouchCancelCapture

onTouchCancelCapture?: TouchEventHandler<HTMLInputElement>

OptionalonTouchEnd

onTouchEnd?: TouchEventHandler<HTMLInputElement>

OptionalonTouchEndCapture

onTouchEndCapture?: TouchEventHandler<HTMLInputElement>

OptionalonTouchMove

onTouchMove?: TouchEventHandler<HTMLInputElement>

OptionalonTouchMoveCapture

onTouchMoveCapture?: TouchEventHandler<HTMLInputElement>

OptionalonTouchStart

onTouchStart?: TouchEventHandler<HTMLInputElement>

OptionalonTouchStartCapture

onTouchStartCapture?: TouchEventHandler<HTMLInputElement>

OptionalonTransitionEnd

onTransitionEnd?: TransitionEventHandler<HTMLInputElement>

OptionalonTransitionEndCapture

onTransitionEndCapture?: TransitionEventHandler<HTMLInputElement>

OptionalonVolumeChange

onVolumeChange?: ReactEventHandler<HTMLInputElement>

OptionalonVolumeChangeCapture

onVolumeChangeCapture?: ReactEventHandler<HTMLInputElement>

OptionalonWaiting

onWaiting?: ReactEventHandler<HTMLInputElement>

OptionalonWaitingCapture

onWaitingCapture?: ReactEventHandler<HTMLInputElement>

OptionalonWheel

onWheel?: WheelEventHandler<HTMLInputElement>

OptionalonWheelCapture

onWheelCapture?: WheelEventHandler<HTMLInputElement>

Optionalopen

open?: boolean

Optionaloptimum

optimum?: number

OptionalouiaId

ouiaId?: string | number

Value to overwrite the randomly generated data-ouia-component-id.

OptionalouiaSafe

ouiaSafe?: boolean

Set the value of data-ouia-safe. Only set to true when the component is in a static state, i.e. no animations are occurring. At all other times, this value must be false.

Optionalpattern

pattern?: string

Optionalplaceholder

placeholder?: string

Placeholder of the text input when there is no value

OptionalplaysInline

playsInline?: boolean

Optionalposter

poster?: string

Optionalprefix

prefix?: string

Optionalpreload

preload?: string

Optionalproperty

property?: string

OptionalradioGroup

radioGroup?: string

OptionalreadOnly

readOnly?: boolean

OptionalreadOnlyVariant

readOnlyVariant?: "default" | "plain"

Sets the input as readonly and determines the readonly styling.

Optionalrel

rel?: string

Optionalrequired

required?: boolean

Optionalresource

resource?: string

Optionalresults

results?: number

Optionalrev

rev?: string

Optionalreversed

reversed?: boolean

Optionalrole

role?: AriaRole

Optionalrows

rows?: number

OptionalrowSpan

rowSpan?: number

Optionalsandbox

sandbox?: string

Optionalscope

scope?: string

Optionalscoped

scoped?: boolean

Optionalscrolling

scrolling?: string

Optionalseamless

seamless?: boolean

Optionalsecurity

security?: string

Optionalselected

selected?: boolean

Optionalshape

shape?: string

Optionalsize

size?: number

Optionalsizes

sizes?: string

Optionalslot

slot?: string

Optionalspan

span?: number

OptionalspellCheck

spellCheck?: Booleanish

Optionalsrc

src?: string

OptionalsrcDoc

srcDoc?: string

OptionalsrcLang

srcLang?: string

OptionalsrcSet

srcSet?: string

Optionalstart

start?: number

Optionalstep

step?: string | number

Optionalstyle

style?: CSSProperties

Optionalsummary

summary?: string

OptionalsuppressContentEditableWarning

suppressContentEditableWarning?: boolean

OptionalsuppressHydrationWarning

suppressHydrationWarning?: boolean

OptionaltabIndex

tabIndex?: number

Optionaltarget

target?: string

Optionaltitle

title?: string

Optionaltranslate

translate?: "yes" | "no"

Optionaltype

type?:
    | "number"
    | "search"
    | "time"
    | "text"
    | "tel"
    | "url"
    | "email"
    | "date"
    | "datetime-local"
    | "month"
    | "password"

Type that the text input accepts.

Optionaltypeof

typeof?: string

Optionalunselectable

unselectable?: "off" | "on"

OptionaluseMap

useMap?: string

Optionalvalidated

validated?:
    | "default"
    | "success"
    | "warning"
    | "error"

Value to indicate if the text input is modified to show that validation state. If set to success, text input will be modified to indicate valid state. If set to error, text input will be modified to indicate error state.

Optionalvalue

value?: string | number

Value of the text input.

Optionalvocab

vocab?: string

Optionalwidth

width?: string | number

Optionalwmode

wmode?: string

Optionalwrap

wrap?: string

Settings

Member Visibility

On This Page

Properties
aboutacceptacceptCharsetaccessKeyactionallowFullScreenallowTransparencyaltaria-activedescendantaria-atomicaria-autocompletearia-braillelabelaria-brailleroledescriptionaria-busyaria-checkedaria-colcountaria-colindexaria-colindextextaria-colspanaria-controlsaria-currentaria-describedbyaria-descriptionaria-detailsaria-disabledaria-dropeffectaria-errormessagearia-expandedaria-flowtoaria-grabbedaria-haspopuparia-hiddenaria-invalidaria-keyshortcutsaria-labelaria-labelledbyaria-levelaria-livearia-modalaria-multilinearia-multiselectablearia-orientationaria-ownsaria-placeholderaria-posinsetaria-pressedaria-readonlyaria-relevantaria-requiredaria-roledescriptionaria-rowcountaria-rowindexaria-rowindextextaria-rowspanaria-selectedaria-setsizearia-sortaria-valuemaxaria-valueminaria-valuenowaria-valuetextasasyncautoCapitalizeautoCompleteautoCorrectautoFocusautoPlayautoSavecapturecellPaddingcellSpacingchallengecharSetcheckedchildrenciteclassIDclassNamecolorcolscolSpancontentcontentEditablecontextMenucontrolscoordscrossOrigincustomIcondangerouslySetInnerHTMLdatadatatypedateTimedefaultdefaultCheckeddefaultValuedeferdirdownloaddraggableencTypeenterKeyHintexpandedPropsformformActionformEncTypeformMethodformNoValidateformTargetframeBorderheadersheighthiddenhighhrefhrefLanghtmlForhttpEquividinlistinnerRefinputModeintegrityisisDisabledisExpandedisLeftTruncatedisRequiredisStartTruncateditemIDitemPropitemRefitemScopeitemTypekeykeyParamskeyTypekindlabellanglistlooplowmanifestmarginHeightmarginWidthmaxmaxLengthmediamediaGroupmethodminminLengthmultiplemutednamenoncenoValidateonAbortonAbortCaptureonAnimationEndonAnimationEndCaptureonAnimationIterationonAnimationIterationCaptureonAnimationStartonAnimationStartCaptureonAuxClickonAuxClickCaptureonBeforeInputonBeforeInputCaptureonBluronBlurCaptureonCanPlayonCanPlayCaptureonCanPlayThroughonCanPlayThroughCaptureonChangeonChangeCaptureonClickonClickCaptureonCompositionEndonCompositionEndCaptureonCompositionStartonCompositionStartCaptureonCompositionUpdateonCompositionUpdateCaptureonContextMenuonContextMenuCaptureonCopyonCopyCaptureonCutonCutCaptureonDoubleClickonDoubleClickCaptureonDragonDragCaptureonDragEndonDragEndCaptureonDragEnteronDragEnterCaptureonDragExitonDragExitCaptureonDragLeaveonDragLeaveCaptureonDragOveronDragOverCaptureonDragStartonDragStartCaptureonDroponDropCaptureonDurationChangeonDurationChangeCaptureonEmptiedonEmptiedCaptureonEncryptedonEncryptedCaptureonEndedonEndedCaptureonErroronErrorCaptureonFocusonFocusCaptureonGotPointerCaptureonGotPointerCaptureCaptureonInputonInputCaptureonInvalidonInvalidCaptureonKeyDownonKeyDownCaptureonKeyPressonKeyPressCaptureonKeyUponKeyUpCaptureonLoadonLoadCaptureonLoadedDataonLoadedDataCaptureonLoadedMetadataonLoadedMetadataCaptureonLoadStartonLoadStartCaptureonLostPointerCaptureonLostPointerCaptureCaptureonMouseDownonMouseDownCaptureonMouseEnteronMouseLeaveonMouseMoveonMouseMoveCaptureonMouseOutonMouseOutCaptureonMouseOveronMouseOverCaptureonMouseUponMouseUpCaptureonPasteonPasteCaptureonPauseonPauseCaptureonPlayonPlayCaptureonPlayingonPlayingCaptureonPointerCancelonPointerCancelCaptureonPointerDownonPointerDownCaptureonPointerEnteronPointerLeaveonPointerMoveonPointerMoveCaptureonPointerOutonPointerOutCaptureonPointerOveronPointerOverCaptureonPointerUponPointerUpCaptureonProgressonProgressCaptureonRateChangeonRateChangeCaptureonResetonResetCaptureonResizeonResizeCaptureonScrollonScrollCaptureonSeekedonSeekedCaptureonSeekingonSeekingCaptureonSelectonSelectCaptureonStalledonStalledCaptureonSubmitonSubmitCaptureonSuspendonSuspendCaptureonTimeUpdateonTimeUpdateCaptureonTouchCancelonTouchCancelCaptureonTouchEndonTouchEndCaptureonTouchMoveonTouchMoveCaptureonTouchStartonTouchStartCaptureonTransitionEndonTransitionEndCaptureonVolumeChangeonVolumeChangeCaptureonWaitingonWaitingCaptureonWheelonWheelCaptureopenoptimumouiaIdouiaSafepatternplaceholderplaysInlineposterprefixpreloadpropertyradioGroupreadOnlyreadOnlyVariantrelrequiredresourceresultsrevreversedrolerowsrowSpansandboxscopescopedscrollingseamlesssecurityselectedshapesizesizesslotspanspellChecksrcsrcDocsrcLangsrcSetstartstepstylesummarysuppressContentEditableWarningsuppressHydrationWarningtabIndextargettitletranslatetypetypeofunselectableuseMapvalidatedvaluevocabwidthwmodewrap