@vincentgraul/react-components 1.0.18 → 1.0.20

package/build/table/Table.d.ts

@@ -18,7 +18,835 @@ export interface TableProps<T> {
     className?: string;
 }
 export default function Table<T>(props: TableProps<T>): JSX.Element;
-export declare const Th: import("styled-components").IStyledComponent<"web", Omit<React.DetailedHTMLProps<React.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never>>;
-export declare const Tr: import("styled-components").IStyledComponent<"web", Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never>>;
-export declare const Td: import("styled-components").IStyledComponent<"web", Omit<React.DetailedHTMLProps<React.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, never>>;
+export declare const Th: import("styled-components").IStyledComponent<"web", {
+    ref?: React.LegacyRef<HTMLTableHeaderCellElement>;
+    key?: React.Key;
+    align?: "center" | "left" | "right" | "justify" | "char";
+    colSpan?: number;
+    headers?: string;
+    rowSpan?: number;
+    scope?: string;
+    abbr?: string;
+    defaultChecked?: boolean;
+    defaultValue?: string | number | readonly string[];
+    suppressContentEditableWarning?: boolean;
+    suppressHydrationWarning?: boolean;
+    accessKey?: string;
+    autoFocus?: boolean;
+    className?: string;
+    contentEditable?: "inherit" | (boolean | "true" | "false");
+    contextMenu?: string;
+    dir?: string;
+    draggable?: boolean | "true" | "false";
+    hidden?: boolean;
+    id?: string;
+    lang?: string;
+    nonce?: string;
+    placeholder?: string;
+    slot?: string;
+    spellCheck?: boolean | "true" | "false";
+    style?: React.CSSProperties;
+    tabIndex?: number;
+    title?: string;
+    translate?: "yes" | "no";
+    radioGroup?: string;
+    role?: React.AriaRole;
+    about?: string;
+    content?: string;
+    datatype?: string;
+    inlist?: any;
+    prefix?: string;
+    property?: string;
+    rel?: string;
+    resource?: string;
+    rev?: string;
+    typeof?: string;
+    vocab?: string;
+    autoCapitalize?: string;
+    autoCorrect?: string;
+    autoSave?: string;
+    color?: string;
+    itemProp?: string;
+    itemScope?: boolean;
+    itemType?: string;
+    itemID?: string;
+    itemRef?: string;
+    results?: number;
+    security?: string;
+    unselectable?: "on" | "off";
+    inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
+    is?: string;
+    'aria-activedescendant'?: string;
+    'aria-atomic'?: boolean | "true" | "false";
+    'aria-autocomplete'?: "none" | "list" | "inline" | "both";
+    'aria-braillelabel'?: string;
+    'aria-brailleroledescription'?: string;
+    'aria-busy'?: boolean | "true" | "false";
+    'aria-checked'?: boolean | "true" | "false" | "mixed";
+    'aria-colcount'?: number;
+    'aria-colindex'?: number;
+    'aria-colindextext'?: string;
+    'aria-colspan'?: number;
+    'aria-controls'?: string;
+    'aria-current'?: boolean | "time" | "page" | "step" | "true" | "false" | "location" | "date";
+    'aria-describedby'?: string;
+    'aria-description'?: string;
+    'aria-details'?: string;
+    'aria-disabled'?: boolean | "true" | "false";
+    'aria-dropeffect'?: "copy" | "link" | "none" | "execute" | "move" | "popup";
+    'aria-errormessage'?: string;
+    'aria-expanded'?: boolean | "true" | "false";
+    'aria-flowto'?: string;
+    'aria-grabbed'?: boolean | "true" | "false";
+    'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
+    'aria-hidden'?: boolean | "true" | "false";
+    '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'?: boolean | "true" | "false";
+    'aria-multiline'?: boolean | "true" | "false";
+    'aria-multiselectable'?: boolean | "true" | "false";
+    'aria-orientation'?: "horizontal" | "vertical";
+    'aria-owns'?: string;
+    'aria-placeholder'?: string;
+    'aria-posinset'?: number;
+    'aria-pressed'?: boolean | "true" | "false" | "mixed";
+    'aria-readonly'?: boolean | "true" | "false";
+    'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
+    'aria-required'?: boolean | "true" | "false";
+    'aria-roledescription'?: string;
+    'aria-rowcount'?: number;
+    'aria-rowindex'?: number;
+    'aria-rowindextext'?: string;
+    'aria-rowspan'?: number;
+    'aria-selected'?: boolean | "true" | "false";
+    'aria-setsize'?: number;
+    'aria-sort'?: "none" | "ascending" | "descending" | "other";
+    'aria-valuemax'?: number;
+    'aria-valuemin'?: number;
+    'aria-valuenow'?: number;
+    'aria-valuetext'?: string;
+    children?: React.ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    };
+    onCopy?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
+    onCopyCapture?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
+    onCut?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
+    onCutCapture?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
+    onPaste?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
+    onPasteCapture?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
+    onCompositionEnd?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
+    onCompositionEndCapture?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
+    onCompositionStart?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
+    onCompositionStartCapture?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
+    onCompositionUpdate?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
+    onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
+    onFocus?: React.FocusEventHandler<HTMLTableHeaderCellElement>;
+    onFocusCapture?: React.FocusEventHandler<HTMLTableHeaderCellElement>;
+    onBlur?: React.FocusEventHandler<HTMLTableHeaderCellElement>;
+    onBlurCapture?: React.FocusEventHandler<HTMLTableHeaderCellElement>;
+    onChange?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onChangeCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onBeforeInput?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onBeforeInputCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onInput?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onInputCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onReset?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onResetCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onSubmit?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onSubmitCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onInvalid?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onInvalidCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
+    onLoad?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onLoadCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onError?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onErrorCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
+    onKeyDownCapture?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
+    onKeyPress?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
+    onKeyPressCapture?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
+    onKeyUp?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
+    onKeyUpCapture?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
+    onAbort?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onAbortCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onCanPlay?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onCanPlayCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onCanPlayThrough?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onCanPlayThroughCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onDurationChange?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onDurationChangeCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onEmptied?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onEmptiedCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onEncrypted?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onEncryptedCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onEnded?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onEndedCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onLoadedData?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onLoadedDataCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onLoadedMetadata?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onLoadedMetadataCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onLoadStart?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onLoadStartCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onPause?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onPauseCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onPlay?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onPlayCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onPlaying?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onPlayingCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onProgress?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onProgressCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onRateChange?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onRateChangeCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onResize?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onResizeCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onSeeked?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onSeekedCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onSeeking?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onSeekingCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onStalled?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onStalledCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onSuspend?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onSuspendCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onTimeUpdate?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onTimeUpdateCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onVolumeChange?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onVolumeChangeCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onWaiting?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onWaitingCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onAuxClick?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onAuxClickCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onClick?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onClickCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onContextMenu?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onContextMenuCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onDoubleClick?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onDoubleClickCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onDrag?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragEnd?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragEndCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragEnter?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragEnterCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragExit?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragExitCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragLeave?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragLeaveCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragOver?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragOverCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragStart?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDragStartCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDrop?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onDropCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
+    onMouseDown?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseDownCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseEnter?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseMove?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseMoveCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseOut?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseOutCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseOver?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseOverCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseUp?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onMouseUpCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
+    onSelect?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onSelectCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
+    onTouchCancel?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
+    onTouchCancelCapture?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
+    onTouchEnd?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
+    onTouchEndCapture?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
+    onTouchMove?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
+    onTouchMoveCapture?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
+    onTouchStart?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
+    onTouchStartCapture?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
+    onPointerDown?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerDownCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerMove?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerMoveCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerUp?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerUpCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerCancel?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerCancelCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerEnter?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerEnterCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerLeave?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerLeaveCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerOver?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerOverCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerOut?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onPointerOutCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onGotPointerCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onLostPointerCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
+    onScroll?: React.UIEventHandler<HTMLTableHeaderCellElement>;
+    onScrollCapture?: React.UIEventHandler<HTMLTableHeaderCellElement>;
+    onWheel?: React.WheelEventHandler<HTMLTableHeaderCellElement>;
+    onWheelCapture?: React.WheelEventHandler<HTMLTableHeaderCellElement>;
+    onAnimationStart?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
+    onAnimationStartCapture?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
+    onAnimationEnd?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
+    onAnimationEndCapture?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
+    onAnimationIteration?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
+    onAnimationIterationCapture?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
+    onTransitionEnd?: React.TransitionEventHandler<HTMLTableHeaderCellElement>;
+    onTransitionEndCapture?: React.TransitionEventHandler<HTMLTableHeaderCellElement>;
+}>;
+export declare const Tr: import("styled-components").IStyledComponent<"web", {
+    ref?: React.LegacyRef<HTMLTableRowElement>;
+    key?: React.Key;
+    defaultChecked?: boolean;
+    defaultValue?: string | number | readonly string[];
+    suppressContentEditableWarning?: boolean;
+    suppressHydrationWarning?: boolean;
+    accessKey?: string;
+    autoFocus?: boolean;
+    className?: string;
+    contentEditable?: "inherit" | (boolean | "true" | "false");
+    contextMenu?: string;
+    dir?: string;
+    draggable?: boolean | "true" | "false";
+    hidden?: boolean;
+    id?: string;
+    lang?: string;
+    nonce?: string;
+    placeholder?: string;
+    slot?: string;
+    spellCheck?: boolean | "true" | "false";
+    style?: React.CSSProperties;
+    tabIndex?: number;
+    title?: string;
+    translate?: "yes" | "no";
+    radioGroup?: string;
+    role?: React.AriaRole;
+    about?: string;
+    content?: string;
+    datatype?: string;
+    inlist?: any;
+    prefix?: string;
+    property?: string;
+    rel?: string;
+    resource?: string;
+    rev?: string;
+    typeof?: string;
+    vocab?: string;
+    autoCapitalize?: string;
+    autoCorrect?: string;
+    autoSave?: string;
+    color?: string;
+    itemProp?: string;
+    itemScope?: boolean;
+    itemType?: string;
+    itemID?: string;
+    itemRef?: string;
+    results?: number;
+    security?: string;
+    unselectable?: "on" | "off";
+    inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
+    is?: string;
+    'aria-activedescendant'?: string;
+    'aria-atomic'?: boolean | "true" | "false";
+    'aria-autocomplete'?: "none" | "list" | "inline" | "both";
+    'aria-braillelabel'?: string;
+    'aria-brailleroledescription'?: string;
+    'aria-busy'?: boolean | "true" | "false";
+    'aria-checked'?: boolean | "true" | "false" | "mixed";
+    'aria-colcount'?: number;
+    'aria-colindex'?: number;
+    'aria-colindextext'?: string;
+    'aria-colspan'?: number;
+    'aria-controls'?: string;
+    'aria-current'?: boolean | "time" | "page" | "step" | "true" | "false" | "location" | "date";
+    'aria-describedby'?: string;
+    'aria-description'?: string;
+    'aria-details'?: string;
+    'aria-disabled'?: boolean | "true" | "false";
+    'aria-dropeffect'?: "copy" | "link" | "none" | "execute" | "move" | "popup";
+    'aria-errormessage'?: string;
+    'aria-expanded'?: boolean | "true" | "false";
+    'aria-flowto'?: string;
+    'aria-grabbed'?: boolean | "true" | "false";
+    'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
+    'aria-hidden'?: boolean | "true" | "false";
+    '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'?: boolean | "true" | "false";
+    'aria-multiline'?: boolean | "true" | "false";
+    'aria-multiselectable'?: boolean | "true" | "false";
+    'aria-orientation'?: "horizontal" | "vertical";
+    'aria-owns'?: string;
+    'aria-placeholder'?: string;
+    'aria-posinset'?: number;
+    'aria-pressed'?: boolean | "true" | "false" | "mixed";
+    'aria-readonly'?: boolean | "true" | "false";
+    'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
+    'aria-required'?: boolean | "true" | "false";
+    'aria-roledescription'?: string;
+    'aria-rowcount'?: number;
+    'aria-rowindex'?: number;
+    'aria-rowindextext'?: string;
+    'aria-rowspan'?: number;
+    'aria-selected'?: boolean | "true" | "false";
+    'aria-setsize'?: number;
+    'aria-sort'?: "none" | "ascending" | "descending" | "other";
+    'aria-valuemax'?: number;
+    'aria-valuemin'?: number;
+    'aria-valuenow'?: number;
+    'aria-valuetext'?: string;
+    children?: React.ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    };
+    onCopy?: React.ClipboardEventHandler<HTMLTableRowElement>;
+    onCopyCapture?: React.ClipboardEventHandler<HTMLTableRowElement>;
+    onCut?: React.ClipboardEventHandler<HTMLTableRowElement>;
+    onCutCapture?: React.ClipboardEventHandler<HTMLTableRowElement>;
+    onPaste?: React.ClipboardEventHandler<HTMLTableRowElement>;
+    onPasteCapture?: React.ClipboardEventHandler<HTMLTableRowElement>;
+    onCompositionEnd?: React.CompositionEventHandler<HTMLTableRowElement>;
+    onCompositionEndCapture?: React.CompositionEventHandler<HTMLTableRowElement>;
+    onCompositionStart?: React.CompositionEventHandler<HTMLTableRowElement>;
+    onCompositionStartCapture?: React.CompositionEventHandler<HTMLTableRowElement>;
+    onCompositionUpdate?: React.CompositionEventHandler<HTMLTableRowElement>;
+    onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLTableRowElement>;
+    onFocus?: React.FocusEventHandler<HTMLTableRowElement>;
+    onFocusCapture?: React.FocusEventHandler<HTMLTableRowElement>;
+    onBlur?: React.FocusEventHandler<HTMLTableRowElement>;
+    onBlurCapture?: React.FocusEventHandler<HTMLTableRowElement>;
+    onChange?: React.FormEventHandler<HTMLTableRowElement>;
+    onChangeCapture?: React.FormEventHandler<HTMLTableRowElement>;
+    onBeforeInput?: React.FormEventHandler<HTMLTableRowElement>;
+    onBeforeInputCapture?: React.FormEventHandler<HTMLTableRowElement>;
+    onInput?: React.FormEventHandler<HTMLTableRowElement>;
+    onInputCapture?: React.FormEventHandler<HTMLTableRowElement>;
+    onReset?: React.FormEventHandler<HTMLTableRowElement>;
+    onResetCapture?: React.FormEventHandler<HTMLTableRowElement>;
+    onSubmit?: React.FormEventHandler<HTMLTableRowElement>;
+    onSubmitCapture?: React.FormEventHandler<HTMLTableRowElement>;
+    onInvalid?: React.FormEventHandler<HTMLTableRowElement>;
+    onInvalidCapture?: React.FormEventHandler<HTMLTableRowElement>;
+    onLoad?: React.ReactEventHandler<HTMLTableRowElement>;
+    onLoadCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onError?: React.ReactEventHandler<HTMLTableRowElement>;
+    onErrorCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLTableRowElement>;
+    onKeyDownCapture?: React.KeyboardEventHandler<HTMLTableRowElement>;
+    onKeyPress?: React.KeyboardEventHandler<HTMLTableRowElement>;
+    onKeyPressCapture?: React.KeyboardEventHandler<HTMLTableRowElement>;
+    onKeyUp?: React.KeyboardEventHandler<HTMLTableRowElement>;
+    onKeyUpCapture?: React.KeyboardEventHandler<HTMLTableRowElement>;
+    onAbort?: React.ReactEventHandler<HTMLTableRowElement>;
+    onAbortCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onCanPlay?: React.ReactEventHandler<HTMLTableRowElement>;
+    onCanPlayCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onCanPlayThrough?: React.ReactEventHandler<HTMLTableRowElement>;
+    onCanPlayThroughCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onDurationChange?: React.ReactEventHandler<HTMLTableRowElement>;
+    onDurationChangeCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onEmptied?: React.ReactEventHandler<HTMLTableRowElement>;
+    onEmptiedCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onEncrypted?: React.ReactEventHandler<HTMLTableRowElement>;
+    onEncryptedCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onEnded?: React.ReactEventHandler<HTMLTableRowElement>;
+    onEndedCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onLoadedData?: React.ReactEventHandler<HTMLTableRowElement>;
+    onLoadedDataCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onLoadedMetadata?: React.ReactEventHandler<HTMLTableRowElement>;
+    onLoadedMetadataCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onLoadStart?: React.ReactEventHandler<HTMLTableRowElement>;
+    onLoadStartCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onPause?: React.ReactEventHandler<HTMLTableRowElement>;
+    onPauseCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onPlay?: React.ReactEventHandler<HTMLTableRowElement>;
+    onPlayCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onPlaying?: React.ReactEventHandler<HTMLTableRowElement>;
+    onPlayingCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onProgress?: React.ReactEventHandler<HTMLTableRowElement>;
+    onProgressCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onRateChange?: React.ReactEventHandler<HTMLTableRowElement>;
+    onRateChangeCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onResize?: React.ReactEventHandler<HTMLTableRowElement>;
+    onResizeCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onSeeked?: React.ReactEventHandler<HTMLTableRowElement>;
+    onSeekedCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onSeeking?: React.ReactEventHandler<HTMLTableRowElement>;
+    onSeekingCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onStalled?: React.ReactEventHandler<HTMLTableRowElement>;
+    onStalledCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onSuspend?: React.ReactEventHandler<HTMLTableRowElement>;
+    onSuspendCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onTimeUpdate?: React.ReactEventHandler<HTMLTableRowElement>;
+    onTimeUpdateCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onVolumeChange?: React.ReactEventHandler<HTMLTableRowElement>;
+    onVolumeChangeCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onWaiting?: React.ReactEventHandler<HTMLTableRowElement>;
+    onWaitingCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onAuxClick?: React.MouseEventHandler<HTMLTableRowElement>;
+    onAuxClickCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onClick?: React.MouseEventHandler<HTMLTableRowElement>;
+    onClickCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onContextMenu?: React.MouseEventHandler<HTMLTableRowElement>;
+    onContextMenuCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onDoubleClick?: React.MouseEventHandler<HTMLTableRowElement>;
+    onDoubleClickCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onDrag?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragCapture?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragEnd?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragEndCapture?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragEnter?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragEnterCapture?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragExit?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragExitCapture?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragLeave?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragLeaveCapture?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragOver?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragOverCapture?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragStart?: React.DragEventHandler<HTMLTableRowElement>;
+    onDragStartCapture?: React.DragEventHandler<HTMLTableRowElement>;
+    onDrop?: React.DragEventHandler<HTMLTableRowElement>;
+    onDropCapture?: React.DragEventHandler<HTMLTableRowElement>;
+    onMouseDown?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseDownCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseEnter?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseMove?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseMoveCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseOut?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseOutCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseOver?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseOverCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseUp?: React.MouseEventHandler<HTMLTableRowElement>;
+    onMouseUpCapture?: React.MouseEventHandler<HTMLTableRowElement>;
+    onSelect?: React.ReactEventHandler<HTMLTableRowElement>;
+    onSelectCapture?: React.ReactEventHandler<HTMLTableRowElement>;
+    onTouchCancel?: React.TouchEventHandler<HTMLTableRowElement>;
+    onTouchCancelCapture?: React.TouchEventHandler<HTMLTableRowElement>;
+    onTouchEnd?: React.TouchEventHandler<HTMLTableRowElement>;
+    onTouchEndCapture?: React.TouchEventHandler<HTMLTableRowElement>;
+    onTouchMove?: React.TouchEventHandler<HTMLTableRowElement>;
+    onTouchMoveCapture?: React.TouchEventHandler<HTMLTableRowElement>;
+    onTouchStart?: React.TouchEventHandler<HTMLTableRowElement>;
+    onTouchStartCapture?: React.TouchEventHandler<HTMLTableRowElement>;
+    onPointerDown?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerDownCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerMove?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerMoveCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerUp?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerUpCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerCancel?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerCancelCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerEnter?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerEnterCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerLeave?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerLeaveCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerOver?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerOverCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerOut?: React.PointerEventHandler<HTMLTableRowElement>;
+    onPointerOutCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onGotPointerCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onLostPointerCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLTableRowElement>;
+    onScroll?: React.UIEventHandler<HTMLTableRowElement>;
+    onScrollCapture?: React.UIEventHandler<HTMLTableRowElement>;
+    onWheel?: React.WheelEventHandler<HTMLTableRowElement>;
+    onWheelCapture?: React.WheelEventHandler<HTMLTableRowElement>;
+    onAnimationStart?: React.AnimationEventHandler<HTMLTableRowElement>;
+    onAnimationStartCapture?: React.AnimationEventHandler<HTMLTableRowElement>;
+    onAnimationEnd?: React.AnimationEventHandler<HTMLTableRowElement>;
+    onAnimationEndCapture?: React.AnimationEventHandler<HTMLTableRowElement>;
+    onAnimationIteration?: React.AnimationEventHandler<HTMLTableRowElement>;
+    onAnimationIterationCapture?: React.AnimationEventHandler<HTMLTableRowElement>;
+    onTransitionEnd?: React.TransitionEventHandler<HTMLTableRowElement>;
+    onTransitionEndCapture?: React.TransitionEventHandler<HTMLTableRowElement>;
+}>;
+export declare const Td: import("styled-components").IStyledComponent<"web", {
+    ref?: React.LegacyRef<HTMLTableDataCellElement>;
+    key?: React.Key;
+    align?: "center" | "left" | "right" | "justify" | "char";
+    colSpan?: number;
+    headers?: string;
+    rowSpan?: number;
+    scope?: string;
+    abbr?: string;
+    height?: string | number;
+    width?: string | number;
+    valign?: "top" | "middle" | "bottom" | "baseline";
+    defaultChecked?: boolean;
+    defaultValue?: string | number | readonly string[];
+    suppressContentEditableWarning?: boolean;
+    suppressHydrationWarning?: boolean;
+    accessKey?: string;
+    autoFocus?: boolean;
+    className?: string;
+    contentEditable?: "inherit" | (boolean | "true" | "false");
+    contextMenu?: string;
+    dir?: string;
+    draggable?: boolean | "true" | "false";
+    hidden?: boolean;
+    id?: string;
+    lang?: string;
+    nonce?: string;
+    placeholder?: string;
+    slot?: string;
+    spellCheck?: boolean | "true" | "false";
+    style?: React.CSSProperties;
+    tabIndex?: number;
+    title?: string;
+    translate?: "yes" | "no";
+    radioGroup?: string;
+    role?: React.AriaRole;
+    about?: string;
+    content?: string;
+    datatype?: string;
+    inlist?: any;
+    prefix?: string;
+    property?: string;
+    rel?: string;
+    resource?: string;
+    rev?: string;
+    typeof?: string;
+    vocab?: string;
+    autoCapitalize?: string;
+    autoCorrect?: string;
+    autoSave?: string;
+    color?: string;
+    itemProp?: string;
+    itemScope?: boolean;
+    itemType?: string;
+    itemID?: string;
+    itemRef?: string;
+    results?: number;
+    security?: string;
+    unselectable?: "on" | "off";
+    inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
+    is?: string;
+    'aria-activedescendant'?: string;
+    'aria-atomic'?: boolean | "true" | "false";
+    'aria-autocomplete'?: "none" | "list" | "inline" | "both";
+    'aria-braillelabel'?: string;
+    'aria-brailleroledescription'?: string;
+    'aria-busy'?: boolean | "true" | "false";
+    'aria-checked'?: boolean | "true" | "false" | "mixed";
+    'aria-colcount'?: number;
+    'aria-colindex'?: number;
+    'aria-colindextext'?: string;
+    'aria-colspan'?: number;
+    'aria-controls'?: string;
+    'aria-current'?: boolean | "time" | "page" | "step" | "true" | "false" | "location" | "date";
+    'aria-describedby'?: string;
+    'aria-description'?: string;
+    'aria-details'?: string;
+    'aria-disabled'?: boolean | "true" | "false";
+    'aria-dropeffect'?: "copy" | "link" | "none" | "execute" | "move" | "popup";
+    'aria-errormessage'?: string;
+    'aria-expanded'?: boolean | "true" | "false";
+    'aria-flowto'?: string;
+    'aria-grabbed'?: boolean | "true" | "false";
+    'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
+    'aria-hidden'?: boolean | "true" | "false";
+    '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'?: boolean | "true" | "false";
+    'aria-multiline'?: boolean | "true" | "false";
+    'aria-multiselectable'?: boolean | "true" | "false";
+    'aria-orientation'?: "horizontal" | "vertical";
+    'aria-owns'?: string;
+    'aria-placeholder'?: string;
+    'aria-posinset'?: number;
+    'aria-pressed'?: boolean | "true" | "false" | "mixed";
+    'aria-readonly'?: boolean | "true" | "false";
+    'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
+    'aria-required'?: boolean | "true" | "false";
+    'aria-roledescription'?: string;
+    'aria-rowcount'?: number;
+    'aria-rowindex'?: number;
+    'aria-rowindextext'?: string;
+    'aria-rowspan'?: number;
+    'aria-selected'?: boolean | "true" | "false";
+    'aria-setsize'?: number;
+    'aria-sort'?: "none" | "ascending" | "descending" | "other";
+    'aria-valuemax'?: number;
+    'aria-valuemin'?: number;
+    'aria-valuenow'?: number;
+    'aria-valuetext'?: string;
+    children?: React.ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    };
+    onCopy?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
+    onCopyCapture?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
+    onCut?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
+    onCutCapture?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
+    onPaste?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
+    onPasteCapture?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
+    onCompositionEnd?: React.CompositionEventHandler<HTMLTableDataCellElement>;
+    onCompositionEndCapture?: React.CompositionEventHandler<HTMLTableDataCellElement>;
+    onCompositionStart?: React.CompositionEventHandler<HTMLTableDataCellElement>;
+    onCompositionStartCapture?: React.CompositionEventHandler<HTMLTableDataCellElement>;
+    onCompositionUpdate?: React.CompositionEventHandler<HTMLTableDataCellElement>;
+    onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLTableDataCellElement>;
+    onFocus?: React.FocusEventHandler<HTMLTableDataCellElement>;
+    onFocusCapture?: React.FocusEventHandler<HTMLTableDataCellElement>;
+    onBlur?: React.FocusEventHandler<HTMLTableDataCellElement>;
+    onBlurCapture?: React.FocusEventHandler<HTMLTableDataCellElement>;
+    onChange?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onChangeCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onBeforeInput?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onBeforeInputCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onInput?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onInputCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onReset?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onResetCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onSubmit?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onSubmitCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onInvalid?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onInvalidCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
+    onLoad?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onLoadCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onError?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onErrorCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
+    onKeyDownCapture?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
+    onKeyPress?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
+    onKeyPressCapture?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
+    onKeyUp?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
+    onKeyUpCapture?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
+    onAbort?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onAbortCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onCanPlay?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onCanPlayCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onCanPlayThrough?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onCanPlayThroughCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onDurationChange?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onDurationChangeCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onEmptied?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onEmptiedCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onEncrypted?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onEncryptedCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onEnded?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onEndedCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onLoadedData?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onLoadedDataCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onLoadedMetadata?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onLoadedMetadataCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onLoadStart?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onLoadStartCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onPause?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onPauseCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onPlay?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onPlayCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onPlaying?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onPlayingCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onProgress?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onProgressCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onRateChange?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onRateChangeCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onResize?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onResizeCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onSeeked?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onSeekedCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onSeeking?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onSeekingCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onStalled?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onStalledCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onSuspend?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onSuspendCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onTimeUpdate?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onTimeUpdateCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onVolumeChange?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onVolumeChangeCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onWaiting?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onWaitingCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onAuxClick?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onAuxClickCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onClick?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onClickCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onContextMenu?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onContextMenuCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onDoubleClick?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onDoubleClickCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onDrag?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragEnd?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragEndCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragEnter?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragEnterCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragExit?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragExitCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragLeave?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragLeaveCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragOver?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragOverCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragStart?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDragStartCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDrop?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onDropCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
+    onMouseDown?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseDownCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseEnter?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseMove?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseMoveCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseOut?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseOutCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseOver?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseOverCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseUp?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onMouseUpCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
+    onSelect?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onSelectCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
+    onTouchCancel?: React.TouchEventHandler<HTMLTableDataCellElement>;
+    onTouchCancelCapture?: React.TouchEventHandler<HTMLTableDataCellElement>;
+    onTouchEnd?: React.TouchEventHandler<HTMLTableDataCellElement>;
+    onTouchEndCapture?: React.TouchEventHandler<HTMLTableDataCellElement>;
+    onTouchMove?: React.TouchEventHandler<HTMLTableDataCellElement>;
+    onTouchMoveCapture?: React.TouchEventHandler<HTMLTableDataCellElement>;
+    onTouchStart?: React.TouchEventHandler<HTMLTableDataCellElement>;
+    onTouchStartCapture?: React.TouchEventHandler<HTMLTableDataCellElement>;
+    onPointerDown?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerDownCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerMove?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerMoveCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerUp?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerUpCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerCancel?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerCancelCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerEnter?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerEnterCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerLeave?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerLeaveCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerOver?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerOverCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerOut?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onPointerOutCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onGotPointerCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onLostPointerCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
+    onScroll?: React.UIEventHandler<HTMLTableDataCellElement>;
+    onScrollCapture?: React.UIEventHandler<HTMLTableDataCellElement>;
+    onWheel?: React.WheelEventHandler<HTMLTableDataCellElement>;
+    onWheelCapture?: React.WheelEventHandler<HTMLTableDataCellElement>;
+    onAnimationStart?: React.AnimationEventHandler<HTMLTableDataCellElement>;
+    onAnimationStartCapture?: React.AnimationEventHandler<HTMLTableDataCellElement>;
+    onAnimationEnd?: React.AnimationEventHandler<HTMLTableDataCellElement>;
+    onAnimationEndCapture?: React.AnimationEventHandler<HTMLTableDataCellElement>;
+    onAnimationIteration?: React.AnimationEventHandler<HTMLTableDataCellElement>;
+    onAnimationIterationCapture?: React.AnimationEventHandler<HTMLTableDataCellElement>;
+    onTransitionEnd?: React.TransitionEventHandler<HTMLTableDataCellElement>;
+    onTransitionEndCapture?: React.TransitionEventHandler<HTMLTableDataCellElement>;
+}>;
 //# sourceMappingURL=Table.d.ts.map