Interface DOMAttributes<T>

interface DOMAttributes<T> {
    children?: ReactNode;
    dangerouslySetInnerHTML?: {
        __html: string;
    };
    onAbort?: ReactEventHandler<T>;
    onAbortCapture?: ReactEventHandler<T>;
    onAnimationEnd?: AnimationEventHandler<T>;
    onAnimationEndCapture?: AnimationEventHandler<T>;
    onAnimationIteration?: AnimationEventHandler<T>;
    onAnimationIterationCapture?: AnimationEventHandler<T>;
    onAnimationStart?: AnimationEventHandler<T>;
    onAnimationStartCapture?: AnimationEventHandler<T>;
    onAuxClick?: MouseEventHandler<T>;
    onAuxClickCapture?: MouseEventHandler<T>;
    onBeforeInput?: FormEventHandler<T>;
    onBeforeInputCapture?: FormEventHandler<T>;
    onBlur?: FocusEventHandler<T>;
    onBlurCapture?: FocusEventHandler<T>;
    onCanPlay?: ReactEventHandler<T>;
    onCanPlayCapture?: ReactEventHandler<T>;
    onCanPlayThrough?: ReactEventHandler<T>;
    onCanPlayThroughCapture?: ReactEventHandler<T>;
    onChange?: FormEventHandler<T>;
    onChangeCapture?: FormEventHandler<T>;
    onClick?: MouseEventHandler<T>;
    onClickCapture?: MouseEventHandler<T>;
    onCompositionEnd?: CompositionEventHandler<T>;
    onCompositionEndCapture?: CompositionEventHandler<T>;
    onCompositionStart?: CompositionEventHandler<T>;
    onCompositionStartCapture?: CompositionEventHandler<T>;
    onCompositionUpdate?: CompositionEventHandler<T>;
    onCompositionUpdateCapture?: CompositionEventHandler<T>;
    onContextMenu?: MouseEventHandler<T>;
    onContextMenuCapture?: MouseEventHandler<T>;
    onCopy?: ClipboardEventHandler<T>;
    onCopyCapture?: ClipboardEventHandler<T>;
    onCut?: ClipboardEventHandler<T>;
    onCutCapture?: ClipboardEventHandler<T>;
    onDoubleClick?: MouseEventHandler<T>;
    onDoubleClickCapture?: MouseEventHandler<T>;
    onDrag?: DragEventHandler<T>;
    onDragCapture?: DragEventHandler<T>;
    onDragEnd?: DragEventHandler<T>;
    onDragEndCapture?: DragEventHandler<T>;
    onDragEnter?: DragEventHandler<T>;
    onDragEnterCapture?: DragEventHandler<T>;
    onDragExit?: DragEventHandler<T>;
    onDragExitCapture?: DragEventHandler<T>;
    onDragLeave?: DragEventHandler<T>;
    onDragLeaveCapture?: DragEventHandler<T>;
    onDragOver?: DragEventHandler<T>;
    onDragOverCapture?: DragEventHandler<T>;
    onDragStart?: DragEventHandler<T>;
    onDragStartCapture?: DragEventHandler<T>;
    onDrop?: DragEventHandler<T>;
    onDropCapture?: DragEventHandler<T>;
    onDurationChange?: ReactEventHandler<T>;
    onDurationChangeCapture?: ReactEventHandler<T>;
    onEmptied?: ReactEventHandler<T>;
    onEmptiedCapture?: ReactEventHandler<T>;
    onEncrypted?: ReactEventHandler<T>;
    onEncryptedCapture?: ReactEventHandler<T>;
    onEnded?: ReactEventHandler<T>;
    onEndedCapture?: ReactEventHandler<T>;
    onError?: ReactEventHandler<T>;
    onErrorCapture?: ReactEventHandler<T>;
    onFocus?: FocusEventHandler<T>;
    onFocusCapture?: FocusEventHandler<T>;
    onGotPointerCapture?: PointerEventHandler<T>;
    onGotPointerCaptureCapture?: PointerEventHandler<T>;
    onInput?: FormEventHandler<T>;
    onInputCapture?: FormEventHandler<T>;
    onInvalid?: FormEventHandler<T>;
    onInvalidCapture?: FormEventHandler<T>;
    onKeyDown?: KeyboardEventHandler<T>;
    onKeyDownCapture?: KeyboardEventHandler<T>;
    onKeyPress?: KeyboardEventHandler<T>;
    onKeyPressCapture?: KeyboardEventHandler<T>;
    onKeyUp?: KeyboardEventHandler<T>;
    onKeyUpCapture?: KeyboardEventHandler<T>;
    onLoad?: ReactEventHandler<T>;
    onLoadCapture?: ReactEventHandler<T>;
    onLoadedData?: ReactEventHandler<T>;
    onLoadedDataCapture?: ReactEventHandler<T>;
    onLoadedMetadata?: ReactEventHandler<T>;
    onLoadedMetadataCapture?: ReactEventHandler<T>;
    onLoadStart?: ReactEventHandler<T>;
    onLoadStartCapture?: ReactEventHandler<T>;
    onLostPointerCapture?: PointerEventHandler<T>;
    onLostPointerCaptureCapture?: PointerEventHandler<T>;
    onMouseDown?: MouseEventHandler<T>;
    onMouseDownCapture?: MouseEventHandler<T>;
    onMouseEnter?: MouseEventHandler<T>;
    onMouseLeave?: MouseEventHandler<T>;
    onMouseMove?: MouseEventHandler<T>;
    onMouseMoveCapture?: MouseEventHandler<T>;
    onMouseOut?: MouseEventHandler<T>;
    onMouseOutCapture?: MouseEventHandler<T>;
    onMouseOver?: MouseEventHandler<T>;
    onMouseOverCapture?: MouseEventHandler<T>;
    onMouseUp?: MouseEventHandler<T>;
    onMouseUpCapture?: MouseEventHandler<T>;
    onPaste?: ClipboardEventHandler<T>;
    onPasteCapture?: ClipboardEventHandler<T>;
    onPause?: ReactEventHandler<T>;
    onPauseCapture?: ReactEventHandler<T>;
    onPlay?: ReactEventHandler<T>;
    onPlayCapture?: ReactEventHandler<T>;
    onPlaying?: ReactEventHandler<T>;
    onPlayingCapture?: ReactEventHandler<T>;
    onPointerCancel?: PointerEventHandler<T>;
    onPointerCancelCapture?: PointerEventHandler<T>;
    onPointerDown?: PointerEventHandler<T>;
    onPointerDownCapture?: PointerEventHandler<T>;
    onPointerEnter?: PointerEventHandler<T>;
    onPointerEnterCapture?: PointerEventHandler<T>;
    onPointerLeave?: PointerEventHandler<T>;
    onPointerLeaveCapture?: PointerEventHandler<T>;
    onPointerMove?: PointerEventHandler<T>;
    onPointerMoveCapture?: PointerEventHandler<T>;
    onPointerOut?: PointerEventHandler<T>;
    onPointerOutCapture?: PointerEventHandler<T>;
    onPointerOver?: PointerEventHandler<T>;
    onPointerOverCapture?: PointerEventHandler<T>;
    onPointerUp?: PointerEventHandler<T>;
    onPointerUpCapture?: PointerEventHandler<T>;
    onProgress?: ReactEventHandler<T>;
    onProgressCapture?: ReactEventHandler<T>;
    onRateChange?: ReactEventHandler<T>;
    onRateChangeCapture?: ReactEventHandler<T>;
    onReset?: FormEventHandler<T>;
    onResetCapture?: FormEventHandler<T>;
    onScroll?: UIEventHandler<T>;
    onScrollCapture?: UIEventHandler<T>;
    onSeeked?: ReactEventHandler<T>;
    onSeekedCapture?: ReactEventHandler<T>;
    onSeeking?: ReactEventHandler<T>;
    onSeekingCapture?: ReactEventHandler<T>;
    onSelect?: ReactEventHandler<T>;
    onSelectCapture?: ReactEventHandler<T>;
    onStalled?: ReactEventHandler<T>;
    onStalledCapture?: ReactEventHandler<T>;
    onSubmit?: FormEventHandler<T>;
    onSubmitCapture?: FormEventHandler<T>;
    onSuspend?: ReactEventHandler<T>;
    onSuspendCapture?: ReactEventHandler<T>;
    onTimeUpdate?: ReactEventHandler<T>;
    onTimeUpdateCapture?: ReactEventHandler<T>;
    onTouchCancel?: TouchEventHandler<T>;
    onTouchCancelCapture?: TouchEventHandler<T>;
    onTouchEnd?: TouchEventHandler<T>;
    onTouchEndCapture?: TouchEventHandler<T>;
    onTouchMove?: TouchEventHandler<T>;
    onTouchMoveCapture?: TouchEventHandler<T>;
    onTouchStart?: TouchEventHandler<T>;
    onTouchStartCapture?: TouchEventHandler<T>;
    onTransitionEnd?: TransitionEventHandler<T>;
    onTransitionEndCapture?: TransitionEventHandler<T>;
    onVolumeChange?: ReactEventHandler<T>;
    onVolumeChangeCapture?: ReactEventHandler<T>;
    onWaiting?: ReactEventHandler<T>;
    onWaitingCapture?: ReactEventHandler<T>;
    onWheel?: WheelEventHandler<T>;
    onWheelCapture?: WheelEventHandler<T>;
}

Type Parameters

T

Hierarchy (view full)

DOMAttributes
- HTMLAttributes
- SVGAttributes

Index

Properties

children? dangerouslySetInnerHTML? 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? onPointerEnterCapture? onPointerLeave? onPointerLeaveCapture? onPointerMove? onPointerMoveCapture? onPointerOut? onPointerOutCapture? onPointerOver? onPointerOverCapture? onPointerUp? onPointerUpCapture? onProgress? onProgressCapture? onRateChange? onRateChangeCapture? onReset? onResetCapture? 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?

Properties

`Optional`children

children?: ReactNode

`Optional`dangerouslySetInnerHTML

dangerouslySetInnerHTML?: {
__html: string;
}

`Optional`onAbort

onAbort?: ReactEventHandler<T>

`Optional`onAbortCapture

onAbortCapture?: ReactEventHandler<T>

`Optional`onAnimationEnd

onAnimationEnd?: AnimationEventHandler<T>

`Optional`onAnimationEndCapture

onAnimationEndCapture?: AnimationEventHandler<T>

`Optional`onAnimationIteration

onAnimationIteration?: AnimationEventHandler<T>

`Optional`onAnimationIterationCapture

onAnimationIterationCapture?: AnimationEventHandler<T>

`Optional`onAnimationStart

onAnimationStart?: AnimationEventHandler<T>

`Optional`onAnimationStartCapture

onAnimationStartCapture?: AnimationEventHandler<T>

`Optional`onAuxClick

onAuxClick?: MouseEventHandler<T>

`Optional`onAuxClickCapture

onAuxClickCapture?: MouseEventHandler<T>

`Optional`onBeforeInput

onBeforeInput?: FormEventHandler<T>

`Optional`onBeforeInputCapture

onBeforeInputCapture?: FormEventHandler<T>

`Optional`onBlur

onBlur?: FocusEventHandler<T>

`Optional`onBlurCapture

onBlurCapture?: FocusEventHandler<T>

`Optional`onCanPlay

onCanPlay?: ReactEventHandler<T>

`Optional`onCanPlayCapture

onCanPlayCapture?: ReactEventHandler<T>

`Optional`onCanPlayThrough

onCanPlayThrough?: ReactEventHandler<T>

`Optional`onCanPlayThroughCapture

onCanPlayThroughCapture?: ReactEventHandler<T>

`Optional`onChange

onChange?: FormEventHandler<T>

`Optional`onChangeCapture

onChangeCapture?: FormEventHandler<T>

`Optional`onClick

onClick?: MouseEventHandler<T>

`Optional`onClickCapture

onClickCapture?: MouseEventHandler<T>

`Optional`onCompositionEnd

onCompositionEnd?: CompositionEventHandler<T>

`Optional`onCompositionEndCapture

onCompositionEndCapture?: CompositionEventHandler<T>

`Optional`onCompositionStart

onCompositionStart?: CompositionEventHandler<T>

`Optional`onCompositionStartCapture

onCompositionStartCapture?: CompositionEventHandler<T>

`Optional`onCompositionUpdate

onCompositionUpdate?: CompositionEventHandler<T>

`Optional`onCompositionUpdateCapture

onCompositionUpdateCapture?: CompositionEventHandler<T>

`Optional`onContextMenu

onContextMenu?: MouseEventHandler<T>

`Optional`onContextMenuCapture

onContextMenuCapture?: MouseEventHandler<T>

`Optional`onCopy

onCopy?: ClipboardEventHandler<T>

`Optional`onCopyCapture

onCopyCapture?: ClipboardEventHandler<T>

`Optional`onCut

onCut?: ClipboardEventHandler<T>

`Optional`onCutCapture

onCutCapture?: ClipboardEventHandler<T>

`Optional`onDoubleClick

onDoubleClick?: MouseEventHandler<T>

`Optional`onDoubleClickCapture

onDoubleClickCapture?: MouseEventHandler<T>

`Optional`onDrag

onDrag?: DragEventHandler<T>

`Optional`onDragCapture

onDragCapture?: DragEventHandler<T>

`Optional`onDragEnd

onDragEnd?: DragEventHandler<T>

`Optional`onDragEndCapture

onDragEndCapture?: DragEventHandler<T>

`Optional`onDragEnter

onDragEnter?: DragEventHandler<T>

`Optional`onDragEnterCapture

onDragEnterCapture?: DragEventHandler<T>

`Optional`onDragExit

onDragExit?: DragEventHandler<T>

`Optional`onDragExitCapture

onDragExitCapture?: DragEventHandler<T>

`Optional`onDragLeave

onDragLeave?: DragEventHandler<T>

`Optional`onDragLeaveCapture

onDragLeaveCapture?: DragEventHandler<T>

`Optional`onDragOver

onDragOver?: DragEventHandler<T>

`Optional`onDragOverCapture

onDragOverCapture?: DragEventHandler<T>

`Optional`onDragStart

onDragStart?: DragEventHandler<T>

`Optional`onDragStartCapture

onDragStartCapture?: DragEventHandler<T>

`Optional`onDrop

onDrop?: DragEventHandler<T>

`Optional`onDropCapture

onDropCapture?: DragEventHandler<T>

`Optional`onDurationChange

onDurationChange?: ReactEventHandler<T>

`Optional`onDurationChangeCapture

onDurationChangeCapture?: ReactEventHandler<T>

`Optional`onEmptied

onEmptied?: ReactEventHandler<T>

`Optional`onEmptiedCapture

onEmptiedCapture?: ReactEventHandler<T>

`Optional`onEncrypted

onEncrypted?: ReactEventHandler<T>

`Optional`onEncryptedCapture

onEncryptedCapture?: ReactEventHandler<T>

`Optional`onEnded

onEnded?: ReactEventHandler<T>

`Optional`onEndedCapture

onEndedCapture?: ReactEventHandler<T>

`Optional`onError

onError?: ReactEventHandler<T>

`Optional`onErrorCapture

onErrorCapture?: ReactEventHandler<T>

`Optional`onFocus

onFocus?: FocusEventHandler<T>

`Optional`onFocusCapture

onFocusCapture?: FocusEventHandler<T>

`Optional`onGotPointerCapture

onGotPointerCapture?: PointerEventHandler<T>

`Optional`onGotPointerCaptureCapture

onGotPointerCaptureCapture?: PointerEventHandler<T>

`Optional`onInput

onInput?: FormEventHandler<T>

`Optional`onInputCapture

onInputCapture?: FormEventHandler<T>

`Optional`onInvalid

onInvalid?: FormEventHandler<T>

`Optional`onInvalidCapture

onInvalidCapture?: FormEventHandler<T>

`Optional`onKeyDown

onKeyDown?: KeyboardEventHandler<T>

`Optional`onKeyDownCapture

onKeyDownCapture?: KeyboardEventHandler<T>

`Optional`onKeyPress

onKeyPress?: KeyboardEventHandler<T>

`Optional`onKeyPressCapture

onKeyPressCapture?: KeyboardEventHandler<T>

`Optional`onKeyUp

onKeyUp?: KeyboardEventHandler<T>

`Optional`onKeyUpCapture

onKeyUpCapture?: KeyboardEventHandler<T>

`Optional`onLoad

onLoad?: ReactEventHandler<T>

`Optional`onLoadCapture

onLoadCapture?: ReactEventHandler<T>

`Optional`onLoadedData

onLoadedData?: ReactEventHandler<T>

`Optional`onLoadedDataCapture

onLoadedDataCapture?: ReactEventHandler<T>

`Optional`onLoadedMetadata

onLoadedMetadata?: ReactEventHandler<T>

`Optional`onLoadedMetadataCapture

onLoadedMetadataCapture?: ReactEventHandler<T>

`Optional`onLoadStart

onLoadStart?: ReactEventHandler<T>

`Optional`onLoadStartCapture

onLoadStartCapture?: ReactEventHandler<T>

`Optional`onLostPointerCapture

onLostPointerCapture?: PointerEventHandler<T>

`Optional`onLostPointerCaptureCapture

onLostPointerCaptureCapture?: PointerEventHandler<T>

`Optional`onMouseDown

onMouseDown?: MouseEventHandler<T>

`Optional`onMouseDownCapture

onMouseDownCapture?: MouseEventHandler<T>

`Optional`onMouseEnter

onMouseEnter?: MouseEventHandler<T>

`Optional`onMouseLeave

onMouseLeave?: MouseEventHandler<T>

`Optional`onMouseMove

onMouseMove?: MouseEventHandler<T>

`Optional`onMouseMoveCapture

onMouseMoveCapture?: MouseEventHandler<T>

`Optional`onMouseOut

onMouseOut?: MouseEventHandler<T>

`Optional`onMouseOutCapture

onMouseOutCapture?: MouseEventHandler<T>

`Optional`onMouseOver

onMouseOver?: MouseEventHandler<T>

`Optional`onMouseOverCapture

onMouseOverCapture?: MouseEventHandler<T>

`Optional`onMouseUp

onMouseUp?: MouseEventHandler<T>

`Optional`onMouseUpCapture

onMouseUpCapture?: MouseEventHandler<T>

`Optional`onPaste

onPaste?: ClipboardEventHandler<T>

`Optional`onPasteCapture

onPasteCapture?: ClipboardEventHandler<T>

`Optional`onPause

onPause?: ReactEventHandler<T>

`Optional`onPauseCapture

onPauseCapture?: ReactEventHandler<T>

`Optional`onPlay

onPlay?: ReactEventHandler<T>

`Optional`onPlayCapture

onPlayCapture?: ReactEventHandler<T>

`Optional`onPlaying

onPlaying?: ReactEventHandler<T>

`Optional`onPlayingCapture

onPlayingCapture?: ReactEventHandler<T>

`Optional`onPointerCancel

onPointerCancel?: PointerEventHandler<T>

`Optional`onPointerCancelCapture

onPointerCancelCapture?: PointerEventHandler<T>

`Optional`onPointerDown

onPointerDown?: PointerEventHandler<T>

`Optional`onPointerDownCapture

onPointerDownCapture?: PointerEventHandler<T>

`Optional`onPointerEnter

onPointerEnter?: PointerEventHandler<T>

`Optional`onPointerEnterCapture

onPointerEnterCapture?: PointerEventHandler<T>

`Optional`onPointerLeave

onPointerLeave?: PointerEventHandler<T>

`Optional`onPointerLeaveCapture

onPointerLeaveCapture?: PointerEventHandler<T>

`Optional`onPointerMove

onPointerMove?: PointerEventHandler<T>

`Optional`onPointerMoveCapture

onPointerMoveCapture?: PointerEventHandler<T>

`Optional`onPointerOut

onPointerOut?: PointerEventHandler<T>

`Optional`onPointerOutCapture

onPointerOutCapture?: PointerEventHandler<T>

`Optional`onPointerOver

onPointerOver?: PointerEventHandler<T>

`Optional`onPointerOverCapture

onPointerOverCapture?: PointerEventHandler<T>

`Optional`onPointerUp

onPointerUp?: PointerEventHandler<T>

`Optional`onPointerUpCapture

onPointerUpCapture?: PointerEventHandler<T>

`Optional`onProgress

onProgress?: ReactEventHandler<T>

`Optional`onProgressCapture

onProgressCapture?: ReactEventHandler<T>

`Optional`onRateChange

onRateChange?: ReactEventHandler<T>

`Optional`onRateChangeCapture

onRateChangeCapture?: ReactEventHandler<T>

`Optional`onReset

onReset?: FormEventHandler<T>

`Optional`onResetCapture

onResetCapture?: FormEventHandler<T>

`Optional`onScroll

onScroll?: UIEventHandler<T>

`Optional`onScrollCapture

onScrollCapture?: UIEventHandler<T>

`Optional`onSeeked

onSeeked?: ReactEventHandler<T>

`Optional`onSeekedCapture

onSeekedCapture?: ReactEventHandler<T>

`Optional`onSeeking

onSeeking?: ReactEventHandler<T>

`Optional`onSeekingCapture

onSeekingCapture?: ReactEventHandler<T>

`Optional`onSelect

onSelect?: ReactEventHandler<T>

`Optional`onSelectCapture

onSelectCapture?: ReactEventHandler<T>

`Optional`onStalled

onStalled?: ReactEventHandler<T>

`Optional`onStalledCapture

onStalledCapture?: ReactEventHandler<T>

`Optional`onSubmit

onSubmit?: FormEventHandler<T>

`Optional`onSubmitCapture

onSubmitCapture?: FormEventHandler<T>

`Optional`onSuspend

onSuspend?: ReactEventHandler<T>

`Optional`onSuspendCapture

onSuspendCapture?: ReactEventHandler<T>

`Optional`onTimeUpdate

onTimeUpdate?: ReactEventHandler<T>

`Optional`onTimeUpdateCapture

onTimeUpdateCapture?: ReactEventHandler<T>

`Optional`onTouchCancel

onTouchCancel?: TouchEventHandler<T>

`Optional`onTouchCancelCapture

onTouchCancelCapture?: TouchEventHandler<T>

`Optional`onTouchEnd

onTouchEnd?: TouchEventHandler<T>

`Optional`onTouchEndCapture

onTouchEndCapture?: TouchEventHandler<T>

`Optional`onTouchMove

onTouchMove?: TouchEventHandler<T>

`Optional`onTouchMoveCapture

onTouchMoveCapture?: TouchEventHandler<T>

`Optional`onTouchStart

onTouchStart?: TouchEventHandler<T>

`Optional`onTouchStartCapture

onTouchStartCapture?: TouchEventHandler<T>

`Optional`onTransitionEnd

onTransitionEnd?: TransitionEventHandler<T>

`Optional`onTransitionEndCapture

onTransitionEndCapture?: TransitionEventHandler<T>

`Optional`onVolumeChange

onVolumeChange?: ReactEventHandler<T>

`Optional`onVolumeChangeCapture

onVolumeChangeCapture?: ReactEventHandler<T>

`Optional`onWaiting

onWaiting?: ReactEventHandler<T>

`Optional`onWaitingCapture

onWaitingCapture?: ReactEventHandler<T>

`Optional`onWheel

onWheel?: WheelEventHandler<T>

`Optional`onWheelCapture

onWheelCapture?: WheelEventHandler<T>