@vincentgraul/react-components 1.0.17 → 1.0.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. package/README.md +2 -0
  2. package/build/language-selector/LanguageSelector.d.ts +12 -0
  3. package/build/language-selector/LanguageSelector.d.ts.map +1 -0
  4. package/build/language-selector/LanguageSelector.js +42 -0
  5. package/build/loader/Loader.js +1 -1
  6. package/build/outside-alerter/useOutsideAlerter.d.ts +6 -1
  7. package/build/outside-alerter/useOutsideAlerter.d.ts.map +1 -1
  8. package/build/outside-alerter/useOutsideAlerter.js +4 -1
  9. package/build/select/Select.d.ts +287 -0
  10. package/build/select/Select.d.ts.map +1 -0
  11. package/build/select/Select.js +92 -0
  12. package/build/table/Table.d.ts +831 -3
  13. package/build/table/Table.d.ts.map +1 -1
  14. package/package.json +16 -12
package/build/table/Table.d.ts CHANGED
@@ -18,7 +18,835 @@ export interface TableProps<T> {
18
18
  className?: string;
19
19
  }
20
20
  export default function Table<T>(props: TableProps<T>): JSX.Element;
21
- export declare const Th: import("styled-components").IStyledComponent<"web", Omit<React.DetailedHTMLProps<React.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never>>;
22
- export declare const Tr: import("styled-components").IStyledComponent<"web", Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never>>;
23
- export declare const Td: import("styled-components").IStyledComponent<"web", Omit<React.DetailedHTMLProps<React.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, never>>;
21
+ export declare const Th: import("styled-components").IStyledComponent<"web", {
22
+ ref?: React.LegacyRef<HTMLTableHeaderCellElement>;
23
+ key?: React.Key;
24
+ align?: "center" | "left" | "right" | "justify" | "char";
25
+ colSpan?: number;
26
+ headers?: string;
27
+ rowSpan?: number;
28
+ scope?: string;
29
+ abbr?: string;
30
+ defaultChecked?: boolean;
31
+ defaultValue?: string | number | readonly string[];
32
+ suppressContentEditableWarning?: boolean;
33
+ suppressHydrationWarning?: boolean;
34
+ accessKey?: string;
35
+ autoFocus?: boolean;
36
+ className?: string;
37
+ contentEditable?: "inherit" | (boolean | "true" | "false");
38
+ contextMenu?: string;
39
+ dir?: string;
40
+ draggable?: boolean | "true" | "false";
41
+ hidden?: boolean;
42
+ id?: string;
43
+ lang?: string;
44
+ nonce?: string;
45
+ placeholder?: string;
46
+ slot?: string;
47
+ spellCheck?: boolean | "true" | "false";
48
+ style?: React.CSSProperties;
49
+ tabIndex?: number;
50
+ title?: string;
51
+ translate?: "yes" | "no";
52
+ radioGroup?: string;
53
+ role?: React.AriaRole;
54
+ about?: string;
55
+ content?: string;
56
+ datatype?: string;
57
+ inlist?: any;
58
+ prefix?: string;
59
+ property?: string;
60
+ rel?: string;
61
+ resource?: string;
62
+ rev?: string;
63
+ typeof?: string;
64
+ vocab?: string;
65
+ autoCapitalize?: string;
66
+ autoCorrect?: string;
67
+ autoSave?: string;
68
+ color?: string;
69
+ itemProp?: string;
70
+ itemScope?: boolean;
71
+ itemType?: string;
72
+ itemID?: string;
73
+ itemRef?: string;
74
+ results?: number;
75
+ security?: string;
76
+ unselectable?: "on" | "off";
77
+ inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
78
+ is?: string;
79
+ 'aria-activedescendant'?: string;
80
+ 'aria-atomic'?: boolean | "true" | "false";
81
+ 'aria-autocomplete'?: "none" | "list" | "inline" | "both";
82
+ 'aria-braillelabel'?: string;
83
+ 'aria-brailleroledescription'?: string;
84
+ 'aria-busy'?: boolean | "true" | "false";
85
+ 'aria-checked'?: boolean | "true" | "false" | "mixed";
86
+ 'aria-colcount'?: number;
87
+ 'aria-colindex'?: number;
88
+ 'aria-colindextext'?: string;
89
+ 'aria-colspan'?: number;
90
+ 'aria-controls'?: string;
91
+ 'aria-current'?: boolean | "time" | "page" | "step" | "true" | "false" | "location" | "date";
92
+ 'aria-describedby'?: string;
93
+ 'aria-description'?: string;
94
+ 'aria-details'?: string;
95
+ 'aria-disabled'?: boolean | "true" | "false";
96
+ 'aria-dropeffect'?: "copy" | "link" | "none" | "execute" | "move" | "popup";
97
+ 'aria-errormessage'?: string;
98
+ 'aria-expanded'?: boolean | "true" | "false";
99
+ 'aria-flowto'?: string;
100
+ 'aria-grabbed'?: boolean | "true" | "false";
101
+ 'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
102
+ 'aria-hidden'?: boolean | "true" | "false";
103
+ 'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling";
104
+ 'aria-keyshortcuts'?: string;
105
+ 'aria-label'?: string;
106
+ 'aria-labelledby'?: string;
107
+ 'aria-level'?: number;
108
+ 'aria-live'?: "off" | "assertive" | "polite";
109
+ 'aria-modal'?: boolean | "true" | "false";
110
+ 'aria-multiline'?: boolean | "true" | "false";
111
+ 'aria-multiselectable'?: boolean | "true" | "false";
112
+ 'aria-orientation'?: "horizontal" | "vertical";
113
+ 'aria-owns'?: string;
114
+ 'aria-placeholder'?: string;
115
+ 'aria-posinset'?: number;
116
+ 'aria-pressed'?: boolean | "true" | "false" | "mixed";
117
+ 'aria-readonly'?: boolean | "true" | "false";
118
+ 'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
119
+ 'aria-required'?: boolean | "true" | "false";
120
+ 'aria-roledescription'?: string;
121
+ 'aria-rowcount'?: number;
122
+ 'aria-rowindex'?: number;
123
+ 'aria-rowindextext'?: string;
124
+ 'aria-rowspan'?: number;
125
+ 'aria-selected'?: boolean | "true" | "false";
126
+ 'aria-setsize'?: number;
127
+ 'aria-sort'?: "none" | "ascending" | "descending" | "other";
128
+ 'aria-valuemax'?: number;
129
+ 'aria-valuemin'?: number;
130
+ 'aria-valuenow'?: number;
131
+ 'aria-valuetext'?: string;
132
+ children?: React.ReactNode;
133
+ dangerouslySetInnerHTML?: {
134
+ __html: string | TrustedHTML;
135
+ };
136
+ onCopy?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
137
+ onCopyCapture?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
138
+ onCut?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
139
+ onCutCapture?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
140
+ onPaste?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
141
+ onPasteCapture?: React.ClipboardEventHandler<HTMLTableHeaderCellElement>;
142
+ onCompositionEnd?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
143
+ onCompositionEndCapture?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
144
+ onCompositionStart?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
145
+ onCompositionStartCapture?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
146
+ onCompositionUpdate?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
147
+ onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLTableHeaderCellElement>;
148
+ onFocus?: React.FocusEventHandler<HTMLTableHeaderCellElement>;
149
+ onFocusCapture?: React.FocusEventHandler<HTMLTableHeaderCellElement>;
150
+ onBlur?: React.FocusEventHandler<HTMLTableHeaderCellElement>;
151
+ onBlurCapture?: React.FocusEventHandler<HTMLTableHeaderCellElement>;
152
+ onChange?: React.FormEventHandler<HTMLTableHeaderCellElement>;
153
+ onChangeCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
154
+ onBeforeInput?: React.FormEventHandler<HTMLTableHeaderCellElement>;
155
+ onBeforeInputCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
156
+ onInput?: React.FormEventHandler<HTMLTableHeaderCellElement>;
157
+ onInputCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
158
+ onReset?: React.FormEventHandler<HTMLTableHeaderCellElement>;
159
+ onResetCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
160
+ onSubmit?: React.FormEventHandler<HTMLTableHeaderCellElement>;
161
+ onSubmitCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
162
+ onInvalid?: React.FormEventHandler<HTMLTableHeaderCellElement>;
163
+ onInvalidCapture?: React.FormEventHandler<HTMLTableHeaderCellElement>;
164
+ onLoad?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
165
+ onLoadCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
166
+ onError?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
167
+ onErrorCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
168
+ onKeyDown?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
169
+ onKeyDownCapture?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
170
+ onKeyPress?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
171
+ onKeyPressCapture?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
172
+ onKeyUp?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
173
+ onKeyUpCapture?: React.KeyboardEventHandler<HTMLTableHeaderCellElement>;
174
+ onAbort?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
175
+ onAbortCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
176
+ onCanPlay?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
177
+ onCanPlayCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
178
+ onCanPlayThrough?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
179
+ onCanPlayThroughCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
180
+ onDurationChange?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
181
+ onDurationChangeCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
182
+ onEmptied?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
183
+ onEmptiedCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
184
+ onEncrypted?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
185
+ onEncryptedCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
186
+ onEnded?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
187
+ onEndedCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
188
+ onLoadedData?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
189
+ onLoadedDataCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
190
+ onLoadedMetadata?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
191
+ onLoadedMetadataCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
192
+ onLoadStart?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
193
+ onLoadStartCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
194
+ onPause?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
195
+ onPauseCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
196
+ onPlay?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
197
+ onPlayCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
198
+ onPlaying?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
199
+ onPlayingCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
200
+ onProgress?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
201
+ onProgressCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
202
+ onRateChange?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
203
+ onRateChangeCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
204
+ onResize?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
205
+ onResizeCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
206
+ onSeeked?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
207
+ onSeekedCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
208
+ onSeeking?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
209
+ onSeekingCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
210
+ onStalled?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
211
+ onStalledCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
212
+ onSuspend?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
213
+ onSuspendCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
214
+ onTimeUpdate?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
215
+ onTimeUpdateCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
216
+ onVolumeChange?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
217
+ onVolumeChangeCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
218
+ onWaiting?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
219
+ onWaitingCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
220
+ onAuxClick?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
221
+ onAuxClickCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
222
+ onClick?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
223
+ onClickCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
224
+ onContextMenu?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
225
+ onContextMenuCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
226
+ onDoubleClick?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
227
+ onDoubleClickCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
228
+ onDrag?: React.DragEventHandler<HTMLTableHeaderCellElement>;
229
+ onDragCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
230
+ onDragEnd?: React.DragEventHandler<HTMLTableHeaderCellElement>;
231
+ onDragEndCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
232
+ onDragEnter?: React.DragEventHandler<HTMLTableHeaderCellElement>;
233
+ onDragEnterCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
234
+ onDragExit?: React.DragEventHandler<HTMLTableHeaderCellElement>;
235
+ onDragExitCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
236
+ onDragLeave?: React.DragEventHandler<HTMLTableHeaderCellElement>;
237
+ onDragLeaveCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
238
+ onDragOver?: React.DragEventHandler<HTMLTableHeaderCellElement>;
239
+ onDragOverCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
240
+ onDragStart?: React.DragEventHandler<HTMLTableHeaderCellElement>;
241
+ onDragStartCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
242
+ onDrop?: React.DragEventHandler<HTMLTableHeaderCellElement>;
243
+ onDropCapture?: React.DragEventHandler<HTMLTableHeaderCellElement>;
244
+ onMouseDown?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
245
+ onMouseDownCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
246
+ onMouseEnter?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
247
+ onMouseLeave?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
248
+ onMouseMove?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
249
+ onMouseMoveCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
250
+ onMouseOut?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
251
+ onMouseOutCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
252
+ onMouseOver?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
253
+ onMouseOverCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
254
+ onMouseUp?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
255
+ onMouseUpCapture?: React.MouseEventHandler<HTMLTableHeaderCellElement>;
256
+ onSelect?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
257
+ onSelectCapture?: React.ReactEventHandler<HTMLTableHeaderCellElement>;
258
+ onTouchCancel?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
259
+ onTouchCancelCapture?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
260
+ onTouchEnd?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
261
+ onTouchEndCapture?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
262
+ onTouchMove?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
263
+ onTouchMoveCapture?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
264
+ onTouchStart?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
265
+ onTouchStartCapture?: React.TouchEventHandler<HTMLTableHeaderCellElement>;
266
+ onPointerDown?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
267
+ onPointerDownCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
268
+ onPointerMove?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
269
+ onPointerMoveCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
270
+ onPointerUp?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
271
+ onPointerUpCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
272
+ onPointerCancel?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
273
+ onPointerCancelCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
274
+ onPointerEnter?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
275
+ onPointerEnterCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
276
+ onPointerLeave?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
277
+ onPointerLeaveCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
278
+ onPointerOver?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
279
+ onPointerOverCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
280
+ onPointerOut?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
281
+ onPointerOutCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
282
+ onGotPointerCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
283
+ onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
284
+ onLostPointerCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
285
+ onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLTableHeaderCellElement>;
286
+ onScroll?: React.UIEventHandler<HTMLTableHeaderCellElement>;
287
+ onScrollCapture?: React.UIEventHandler<HTMLTableHeaderCellElement>;
288
+ onWheel?: React.WheelEventHandler<HTMLTableHeaderCellElement>;
289
+ onWheelCapture?: React.WheelEventHandler<HTMLTableHeaderCellElement>;
290
+ onAnimationStart?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
291
+ onAnimationStartCapture?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
292
+ onAnimationEnd?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
293
+ onAnimationEndCapture?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
294
+ onAnimationIteration?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
295
+ onAnimationIterationCapture?: React.AnimationEventHandler<HTMLTableHeaderCellElement>;
296
+ onTransitionEnd?: React.TransitionEventHandler<HTMLTableHeaderCellElement>;
297
+ onTransitionEndCapture?: React.TransitionEventHandler<HTMLTableHeaderCellElement>;
298
+ }>;
299
+ export declare const Tr: import("styled-components").IStyledComponent<"web", {
300
+ ref?: React.LegacyRef<HTMLTableRowElement>;
301
+ key?: React.Key;
302
+ defaultChecked?: boolean;
303
+ defaultValue?: string | number | readonly string[];
304
+ suppressContentEditableWarning?: boolean;
305
+ suppressHydrationWarning?: boolean;
306
+ accessKey?: string;
307
+ autoFocus?: boolean;
308
+ className?: string;
309
+ contentEditable?: "inherit" | (boolean | "true" | "false");
310
+ contextMenu?: string;
311
+ dir?: string;
312
+ draggable?: boolean | "true" | "false";
313
+ hidden?: boolean;
314
+ id?: string;
315
+ lang?: string;
316
+ nonce?: string;
317
+ placeholder?: string;
318
+ slot?: string;
319
+ spellCheck?: boolean | "true" | "false";
320
+ style?: React.CSSProperties;
321
+ tabIndex?: number;
322
+ title?: string;
323
+ translate?: "yes" | "no";
324
+ radioGroup?: string;
325
+ role?: React.AriaRole;
326
+ about?: string;
327
+ content?: string;
328
+ datatype?: string;
329
+ inlist?: any;
330
+ prefix?: string;
331
+ property?: string;
332
+ rel?: string;
333
+ resource?: string;
334
+ rev?: string;
335
+ typeof?: string;
336
+ vocab?: string;
337
+ autoCapitalize?: string;
338
+ autoCorrect?: string;
339
+ autoSave?: string;
340
+ color?: string;
341
+ itemProp?: string;
342
+ itemScope?: boolean;
343
+ itemType?: string;
344
+ itemID?: string;
345
+ itemRef?: string;
346
+ results?: number;
347
+ security?: string;
348
+ unselectable?: "on" | "off";
349
+ inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
350
+ is?: string;
351
+ 'aria-activedescendant'?: string;
352
+ 'aria-atomic'?: boolean | "true" | "false";
353
+ 'aria-autocomplete'?: "none" | "list" | "inline" | "both";
354
+ 'aria-braillelabel'?: string;
355
+ 'aria-brailleroledescription'?: string;
356
+ 'aria-busy'?: boolean | "true" | "false";
357
+ 'aria-checked'?: boolean | "true" | "false" | "mixed";
358
+ 'aria-colcount'?: number;
359
+ 'aria-colindex'?: number;
360
+ 'aria-colindextext'?: string;
361
+ 'aria-colspan'?: number;
362
+ 'aria-controls'?: string;
363
+ 'aria-current'?: boolean | "time" | "page" | "step" | "true" | "false" | "location" | "date";
364
+ 'aria-describedby'?: string;
365
+ 'aria-description'?: string;
366
+ 'aria-details'?: string;
367
+ 'aria-disabled'?: boolean | "true" | "false";
368
+ 'aria-dropeffect'?: "copy" | "link" | "none" | "execute" | "move" | "popup";
369
+ 'aria-errormessage'?: string;
370
+ 'aria-expanded'?: boolean | "true" | "false";
371
+ 'aria-flowto'?: string;
372
+ 'aria-grabbed'?: boolean | "true" | "false";
373
+ 'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
374
+ 'aria-hidden'?: boolean | "true" | "false";
375
+ 'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling";
376
+ 'aria-keyshortcuts'?: string;
377
+ 'aria-label'?: string;
378
+ 'aria-labelledby'?: string;
379
+ 'aria-level'?: number;
380
+ 'aria-live'?: "off" | "assertive" | "polite";
381
+ 'aria-modal'?: boolean | "true" | "false";
382
+ 'aria-multiline'?: boolean | "true" | "false";
383
+ 'aria-multiselectable'?: boolean | "true" | "false";
384
+ 'aria-orientation'?: "horizontal" | "vertical";
385
+ 'aria-owns'?: string;
386
+ 'aria-placeholder'?: string;
387
+ 'aria-posinset'?: number;
388
+ 'aria-pressed'?: boolean | "true" | "false" | "mixed";
389
+ 'aria-readonly'?: boolean | "true" | "false";
390
+ 'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
391
+ 'aria-required'?: boolean | "true" | "false";
392
+ 'aria-roledescription'?: string;
393
+ 'aria-rowcount'?: number;
394
+ 'aria-rowindex'?: number;
395
+ 'aria-rowindextext'?: string;
396
+ 'aria-rowspan'?: number;
397
+ 'aria-selected'?: boolean | "true" | "false";
398
+ 'aria-setsize'?: number;
399
+ 'aria-sort'?: "none" | "ascending" | "descending" | "other";
400
+ 'aria-valuemax'?: number;
401
+ 'aria-valuemin'?: number;
402
+ 'aria-valuenow'?: number;
403
+ 'aria-valuetext'?: string;
404
+ children?: React.ReactNode;
405
+ dangerouslySetInnerHTML?: {
406
+ __html: string | TrustedHTML;
407
+ };
408
+ onCopy?: React.ClipboardEventHandler<HTMLTableRowElement>;
409
+ onCopyCapture?: React.ClipboardEventHandler<HTMLTableRowElement>;
410
+ onCut?: React.ClipboardEventHandler<HTMLTableRowElement>;
411
+ onCutCapture?: React.ClipboardEventHandler<HTMLTableRowElement>;
412
+ onPaste?: React.ClipboardEventHandler<HTMLTableRowElement>;
413
+ onPasteCapture?: React.ClipboardEventHandler<HTMLTableRowElement>;
414
+ onCompositionEnd?: React.CompositionEventHandler<HTMLTableRowElement>;
415
+ onCompositionEndCapture?: React.CompositionEventHandler<HTMLTableRowElement>;
416
+ onCompositionStart?: React.CompositionEventHandler<HTMLTableRowElement>;
417
+ onCompositionStartCapture?: React.CompositionEventHandler<HTMLTableRowElement>;
418
+ onCompositionUpdate?: React.CompositionEventHandler<HTMLTableRowElement>;
419
+ onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLTableRowElement>;
420
+ onFocus?: React.FocusEventHandler<HTMLTableRowElement>;
421
+ onFocusCapture?: React.FocusEventHandler<HTMLTableRowElement>;
422
+ onBlur?: React.FocusEventHandler<HTMLTableRowElement>;
423
+ onBlurCapture?: React.FocusEventHandler<HTMLTableRowElement>;
424
+ onChange?: React.FormEventHandler<HTMLTableRowElement>;
425
+ onChangeCapture?: React.FormEventHandler<HTMLTableRowElement>;
426
+ onBeforeInput?: React.FormEventHandler<HTMLTableRowElement>;
427
+ onBeforeInputCapture?: React.FormEventHandler<HTMLTableRowElement>;
428
+ onInput?: React.FormEventHandler<HTMLTableRowElement>;
429
+ onInputCapture?: React.FormEventHandler<HTMLTableRowElement>;
430
+ onReset?: React.FormEventHandler<HTMLTableRowElement>;
431
+ onResetCapture?: React.FormEventHandler<HTMLTableRowElement>;
432
+ onSubmit?: React.FormEventHandler<HTMLTableRowElement>;
433
+ onSubmitCapture?: React.FormEventHandler<HTMLTableRowElement>;
434
+ onInvalid?: React.FormEventHandler<HTMLTableRowElement>;
435
+ onInvalidCapture?: React.FormEventHandler<HTMLTableRowElement>;
436
+ onLoad?: React.ReactEventHandler<HTMLTableRowElement>;
437
+ onLoadCapture?: React.ReactEventHandler<HTMLTableRowElement>;
438
+ onError?: React.ReactEventHandler<HTMLTableRowElement>;
439
+ onErrorCapture?: React.ReactEventHandler<HTMLTableRowElement>;
440
+ onKeyDown?: React.KeyboardEventHandler<HTMLTableRowElement>;
441
+ onKeyDownCapture?: React.KeyboardEventHandler<HTMLTableRowElement>;
442
+ onKeyPress?: React.KeyboardEventHandler<HTMLTableRowElement>;
443
+ onKeyPressCapture?: React.KeyboardEventHandler<HTMLTableRowElement>;
444
+ onKeyUp?: React.KeyboardEventHandler<HTMLTableRowElement>;
445
+ onKeyUpCapture?: React.KeyboardEventHandler<HTMLTableRowElement>;
446
+ onAbort?: React.ReactEventHandler<HTMLTableRowElement>;
447
+ onAbortCapture?: React.ReactEventHandler<HTMLTableRowElement>;
448
+ onCanPlay?: React.ReactEventHandler<HTMLTableRowElement>;
449
+ onCanPlayCapture?: React.ReactEventHandler<HTMLTableRowElement>;
450
+ onCanPlayThrough?: React.ReactEventHandler<HTMLTableRowElement>;
451
+ onCanPlayThroughCapture?: React.ReactEventHandler<HTMLTableRowElement>;
452
+ onDurationChange?: React.ReactEventHandler<HTMLTableRowElement>;
453
+ onDurationChangeCapture?: React.ReactEventHandler<HTMLTableRowElement>;
454
+ onEmptied?: React.ReactEventHandler<HTMLTableRowElement>;
455
+ onEmptiedCapture?: React.ReactEventHandler<HTMLTableRowElement>;
456
+ onEncrypted?: React.ReactEventHandler<HTMLTableRowElement>;
457
+ onEncryptedCapture?: React.ReactEventHandler<HTMLTableRowElement>;
458
+ onEnded?: React.ReactEventHandler<HTMLTableRowElement>;
459
+ onEndedCapture?: React.ReactEventHandler<HTMLTableRowElement>;
460
+ onLoadedData?: React.ReactEventHandler<HTMLTableRowElement>;
461
+ onLoadedDataCapture?: React.ReactEventHandler<HTMLTableRowElement>;
462
+ onLoadedMetadata?: React.ReactEventHandler<HTMLTableRowElement>;
463
+ onLoadedMetadataCapture?: React.ReactEventHandler<HTMLTableRowElement>;
464
+ onLoadStart?: React.ReactEventHandler<HTMLTableRowElement>;
465
+ onLoadStartCapture?: React.ReactEventHandler<HTMLTableRowElement>;
466
+ onPause?: React.ReactEventHandler<HTMLTableRowElement>;
467
+ onPauseCapture?: React.ReactEventHandler<HTMLTableRowElement>;
468
+ onPlay?: React.ReactEventHandler<HTMLTableRowElement>;
469
+ onPlayCapture?: React.ReactEventHandler<HTMLTableRowElement>;
470
+ onPlaying?: React.ReactEventHandler<HTMLTableRowElement>;
471
+ onPlayingCapture?: React.ReactEventHandler<HTMLTableRowElement>;
472
+ onProgress?: React.ReactEventHandler<HTMLTableRowElement>;
473
+ onProgressCapture?: React.ReactEventHandler<HTMLTableRowElement>;
474
+ onRateChange?: React.ReactEventHandler<HTMLTableRowElement>;
475
+ onRateChangeCapture?: React.ReactEventHandler<HTMLTableRowElement>;
476
+ onResize?: React.ReactEventHandler<HTMLTableRowElement>;
477
+ onResizeCapture?: React.ReactEventHandler<HTMLTableRowElement>;
478
+ onSeeked?: React.ReactEventHandler<HTMLTableRowElement>;
479
+ onSeekedCapture?: React.ReactEventHandler<HTMLTableRowElement>;
480
+ onSeeking?: React.ReactEventHandler<HTMLTableRowElement>;
481
+ onSeekingCapture?: React.ReactEventHandler<HTMLTableRowElement>;
482
+ onStalled?: React.ReactEventHandler<HTMLTableRowElement>;
483
+ onStalledCapture?: React.ReactEventHandler<HTMLTableRowElement>;
484
+ onSuspend?: React.ReactEventHandler<HTMLTableRowElement>;
485
+ onSuspendCapture?: React.ReactEventHandler<HTMLTableRowElement>;
486
+ onTimeUpdate?: React.ReactEventHandler<HTMLTableRowElement>;
487
+ onTimeUpdateCapture?: React.ReactEventHandler<HTMLTableRowElement>;
488
+ onVolumeChange?: React.ReactEventHandler<HTMLTableRowElement>;
489
+ onVolumeChangeCapture?: React.ReactEventHandler<HTMLTableRowElement>;
490
+ onWaiting?: React.ReactEventHandler<HTMLTableRowElement>;
491
+ onWaitingCapture?: React.ReactEventHandler<HTMLTableRowElement>;
492
+ onAuxClick?: React.MouseEventHandler<HTMLTableRowElement>;
493
+ onAuxClickCapture?: React.MouseEventHandler<HTMLTableRowElement>;
494
+ onClick?: React.MouseEventHandler<HTMLTableRowElement>;
495
+ onClickCapture?: React.MouseEventHandler<HTMLTableRowElement>;
496
+ onContextMenu?: React.MouseEventHandler<HTMLTableRowElement>;
497
+ onContextMenuCapture?: React.MouseEventHandler<HTMLTableRowElement>;
498
+ onDoubleClick?: React.MouseEventHandler<HTMLTableRowElement>;
499
+ onDoubleClickCapture?: React.MouseEventHandler<HTMLTableRowElement>;
500
+ onDrag?: React.DragEventHandler<HTMLTableRowElement>;
501
+ onDragCapture?: React.DragEventHandler<HTMLTableRowElement>;
502
+ onDragEnd?: React.DragEventHandler<HTMLTableRowElement>;
503
+ onDragEndCapture?: React.DragEventHandler<HTMLTableRowElement>;
504
+ onDragEnter?: React.DragEventHandler<HTMLTableRowElement>;
505
+ onDragEnterCapture?: React.DragEventHandler<HTMLTableRowElement>;
506
+ onDragExit?: React.DragEventHandler<HTMLTableRowElement>;
507
+ onDragExitCapture?: React.DragEventHandler<HTMLTableRowElement>;
508
+ onDragLeave?: React.DragEventHandler<HTMLTableRowElement>;
509
+ onDragLeaveCapture?: React.DragEventHandler<HTMLTableRowElement>;
510
+ onDragOver?: React.DragEventHandler<HTMLTableRowElement>;
511
+ onDragOverCapture?: React.DragEventHandler<HTMLTableRowElement>;
512
+ onDragStart?: React.DragEventHandler<HTMLTableRowElement>;
513
+ onDragStartCapture?: React.DragEventHandler<HTMLTableRowElement>;
514
+ onDrop?: React.DragEventHandler<HTMLTableRowElement>;
515
+ onDropCapture?: React.DragEventHandler<HTMLTableRowElement>;
516
+ onMouseDown?: React.MouseEventHandler<HTMLTableRowElement>;
517
+ onMouseDownCapture?: React.MouseEventHandler<HTMLTableRowElement>;
518
+ onMouseEnter?: React.MouseEventHandler<HTMLTableRowElement>;
519
+ onMouseLeave?: React.MouseEventHandler<HTMLTableRowElement>;
520
+ onMouseMove?: React.MouseEventHandler<HTMLTableRowElement>;
521
+ onMouseMoveCapture?: React.MouseEventHandler<HTMLTableRowElement>;
522
+ onMouseOut?: React.MouseEventHandler<HTMLTableRowElement>;
523
+ onMouseOutCapture?: React.MouseEventHandler<HTMLTableRowElement>;
524
+ onMouseOver?: React.MouseEventHandler<HTMLTableRowElement>;
525
+ onMouseOverCapture?: React.MouseEventHandler<HTMLTableRowElement>;
526
+ onMouseUp?: React.MouseEventHandler<HTMLTableRowElement>;
527
+ onMouseUpCapture?: React.MouseEventHandler<HTMLTableRowElement>;
528
+ onSelect?: React.ReactEventHandler<HTMLTableRowElement>;
529
+ onSelectCapture?: React.ReactEventHandler<HTMLTableRowElement>;
530
+ onTouchCancel?: React.TouchEventHandler<HTMLTableRowElement>;
531
+ onTouchCancelCapture?: React.TouchEventHandler<HTMLTableRowElement>;
532
+ onTouchEnd?: React.TouchEventHandler<HTMLTableRowElement>;
533
+ onTouchEndCapture?: React.TouchEventHandler<HTMLTableRowElement>;
534
+ onTouchMove?: React.TouchEventHandler<HTMLTableRowElement>;
535
+ onTouchMoveCapture?: React.TouchEventHandler<HTMLTableRowElement>;
536
+ onTouchStart?: React.TouchEventHandler<HTMLTableRowElement>;
537
+ onTouchStartCapture?: React.TouchEventHandler<HTMLTableRowElement>;
538
+ onPointerDown?: React.PointerEventHandler<HTMLTableRowElement>;
539
+ onPointerDownCapture?: React.PointerEventHandler<HTMLTableRowElement>;
540
+ onPointerMove?: React.PointerEventHandler<HTMLTableRowElement>;
541
+ onPointerMoveCapture?: React.PointerEventHandler<HTMLTableRowElement>;
542
+ onPointerUp?: React.PointerEventHandler<HTMLTableRowElement>;
543
+ onPointerUpCapture?: React.PointerEventHandler<HTMLTableRowElement>;
544
+ onPointerCancel?: React.PointerEventHandler<HTMLTableRowElement>;
545
+ onPointerCancelCapture?: React.PointerEventHandler<HTMLTableRowElement>;
546
+ onPointerEnter?: React.PointerEventHandler<HTMLTableRowElement>;
547
+ onPointerEnterCapture?: React.PointerEventHandler<HTMLTableRowElement>;
548
+ onPointerLeave?: React.PointerEventHandler<HTMLTableRowElement>;
549
+ onPointerLeaveCapture?: React.PointerEventHandler<HTMLTableRowElement>;
550
+ onPointerOver?: React.PointerEventHandler<HTMLTableRowElement>;
551
+ onPointerOverCapture?: React.PointerEventHandler<HTMLTableRowElement>;
552
+ onPointerOut?: React.PointerEventHandler<HTMLTableRowElement>;
553
+ onPointerOutCapture?: React.PointerEventHandler<HTMLTableRowElement>;
554
+ onGotPointerCapture?: React.PointerEventHandler<HTMLTableRowElement>;
555
+ onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLTableRowElement>;
556
+ onLostPointerCapture?: React.PointerEventHandler<HTMLTableRowElement>;
557
+ onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLTableRowElement>;
558
+ onScroll?: React.UIEventHandler<HTMLTableRowElement>;
559
+ onScrollCapture?: React.UIEventHandler<HTMLTableRowElement>;
560
+ onWheel?: React.WheelEventHandler<HTMLTableRowElement>;
561
+ onWheelCapture?: React.WheelEventHandler<HTMLTableRowElement>;
562
+ onAnimationStart?: React.AnimationEventHandler<HTMLTableRowElement>;
563
+ onAnimationStartCapture?: React.AnimationEventHandler<HTMLTableRowElement>;
564
+ onAnimationEnd?: React.AnimationEventHandler<HTMLTableRowElement>;
565
+ onAnimationEndCapture?: React.AnimationEventHandler<HTMLTableRowElement>;
566
+ onAnimationIteration?: React.AnimationEventHandler<HTMLTableRowElement>;
567
+ onAnimationIterationCapture?: React.AnimationEventHandler<HTMLTableRowElement>;
568
+ onTransitionEnd?: React.TransitionEventHandler<HTMLTableRowElement>;
569
+ onTransitionEndCapture?: React.TransitionEventHandler<HTMLTableRowElement>;
570
+ }>;
571
+ export declare const Td: import("styled-components").IStyledComponent<"web", {
572
+ ref?: React.LegacyRef<HTMLTableDataCellElement>;
573
+ key?: React.Key;
574
+ align?: "center" | "left" | "right" | "justify" | "char";
575
+ colSpan?: number;
576
+ headers?: string;
577
+ rowSpan?: number;
578
+ scope?: string;
579
+ abbr?: string;
580
+ height?: string | number;
581
+ width?: string | number;
582
+ valign?: "top" | "middle" | "bottom" | "baseline";
583
+ defaultChecked?: boolean;
584
+ defaultValue?: string | number | readonly string[];
585
+ suppressContentEditableWarning?: boolean;
586
+ suppressHydrationWarning?: boolean;
587
+ accessKey?: string;
588
+ autoFocus?: boolean;
589
+ className?: string;
590
+ contentEditable?: "inherit" | (boolean | "true" | "false");
591
+ contextMenu?: string;
592
+ dir?: string;
593
+ draggable?: boolean | "true" | "false";
594
+ hidden?: boolean;
595
+ id?: string;
596
+ lang?: string;
597
+ nonce?: string;
598
+ placeholder?: string;
599
+ slot?: string;
600
+ spellCheck?: boolean | "true" | "false";
601
+ style?: React.CSSProperties;
602
+ tabIndex?: number;
603
+ title?: string;
604
+ translate?: "yes" | "no";
605
+ radioGroup?: string;
606
+ role?: React.AriaRole;
607
+ about?: string;
608
+ content?: string;
609
+ datatype?: string;
610
+ inlist?: any;
611
+ prefix?: string;
612
+ property?: string;
613
+ rel?: string;
614
+ resource?: string;
615
+ rev?: string;
616
+ typeof?: string;
617
+ vocab?: string;
618
+ autoCapitalize?: string;
619
+ autoCorrect?: string;
620
+ autoSave?: string;
621
+ color?: string;
622
+ itemProp?: string;
623
+ itemScope?: boolean;
624
+ itemType?: string;
625
+ itemID?: string;
626
+ itemRef?: string;
627
+ results?: number;
628
+ security?: string;
629
+ unselectable?: "on" | "off";
630
+ inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
631
+ is?: string;
632
+ 'aria-activedescendant'?: string;
633
+ 'aria-atomic'?: boolean | "true" | "false";
634
+ 'aria-autocomplete'?: "none" | "list" | "inline" | "both";
635
+ 'aria-braillelabel'?: string;
636
+ 'aria-brailleroledescription'?: string;
637
+ 'aria-busy'?: boolean | "true" | "false";
638
+ 'aria-checked'?: boolean | "true" | "false" | "mixed";
639
+ 'aria-colcount'?: number;
640
+ 'aria-colindex'?: number;
641
+ 'aria-colindextext'?: string;
642
+ 'aria-colspan'?: number;
643
+ 'aria-controls'?: string;
644
+ 'aria-current'?: boolean | "time" | "page" | "step" | "true" | "false" | "location" | "date";
645
+ 'aria-describedby'?: string;
646
+ 'aria-description'?: string;
647
+ 'aria-details'?: string;
648
+ 'aria-disabled'?: boolean | "true" | "false";
649
+ 'aria-dropeffect'?: "copy" | "link" | "none" | "execute" | "move" | "popup";
650
+ 'aria-errormessage'?: string;
651
+ 'aria-expanded'?: boolean | "true" | "false";
652
+ 'aria-flowto'?: string;
653
+ 'aria-grabbed'?: boolean | "true" | "false";
654
+ 'aria-haspopup'?: boolean | "dialog" | "menu" | "true" | "false" | "grid" | "listbox" | "tree";
655
+ 'aria-hidden'?: boolean | "true" | "false";
656
+ 'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling";
657
+ 'aria-keyshortcuts'?: string;
658
+ 'aria-label'?: string;
659
+ 'aria-labelledby'?: string;
660
+ 'aria-level'?: number;
661
+ 'aria-live'?: "off" | "assertive" | "polite";
662
+ 'aria-modal'?: boolean | "true" | "false";
663
+ 'aria-multiline'?: boolean | "true" | "false";
664
+ 'aria-multiselectable'?: boolean | "true" | "false";
665
+ 'aria-orientation'?: "horizontal" | "vertical";
666
+ 'aria-owns'?: string;
667
+ 'aria-placeholder'?: string;
668
+ 'aria-posinset'?: number;
669
+ 'aria-pressed'?: boolean | "true" | "false" | "mixed";
670
+ 'aria-readonly'?: boolean | "true" | "false";
671
+ 'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
672
+ 'aria-required'?: boolean | "true" | "false";
673
+ 'aria-roledescription'?: string;
674
+ 'aria-rowcount'?: number;
675
+ 'aria-rowindex'?: number;
676
+ 'aria-rowindextext'?: string;
677
+ 'aria-rowspan'?: number;
678
+ 'aria-selected'?: boolean | "true" | "false";
679
+ 'aria-setsize'?: number;
680
+ 'aria-sort'?: "none" | "ascending" | "descending" | "other";
681
+ 'aria-valuemax'?: number;
682
+ 'aria-valuemin'?: number;
683
+ 'aria-valuenow'?: number;
684
+ 'aria-valuetext'?: string;
685
+ children?: React.ReactNode;
686
+ dangerouslySetInnerHTML?: {
687
+ __html: string | TrustedHTML;
688
+ };
689
+ onCopy?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
690
+ onCopyCapture?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
691
+ onCut?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
692
+ onCutCapture?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
693
+ onPaste?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
694
+ onPasteCapture?: React.ClipboardEventHandler<HTMLTableDataCellElement>;
695
+ onCompositionEnd?: React.CompositionEventHandler<HTMLTableDataCellElement>;
696
+ onCompositionEndCapture?: React.CompositionEventHandler<HTMLTableDataCellElement>;
697
+ onCompositionStart?: React.CompositionEventHandler<HTMLTableDataCellElement>;
698
+ onCompositionStartCapture?: React.CompositionEventHandler<HTMLTableDataCellElement>;
699
+ onCompositionUpdate?: React.CompositionEventHandler<HTMLTableDataCellElement>;
700
+ onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLTableDataCellElement>;
701
+ onFocus?: React.FocusEventHandler<HTMLTableDataCellElement>;
702
+ onFocusCapture?: React.FocusEventHandler<HTMLTableDataCellElement>;
703
+ onBlur?: React.FocusEventHandler<HTMLTableDataCellElement>;
704
+ onBlurCapture?: React.FocusEventHandler<HTMLTableDataCellElement>;
705
+ onChange?: React.FormEventHandler<HTMLTableDataCellElement>;
706
+ onChangeCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
707
+ onBeforeInput?: React.FormEventHandler<HTMLTableDataCellElement>;
708
+ onBeforeInputCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
709
+ onInput?: React.FormEventHandler<HTMLTableDataCellElement>;
710
+ onInputCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
711
+ onReset?: React.FormEventHandler<HTMLTableDataCellElement>;
712
+ onResetCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
713
+ onSubmit?: React.FormEventHandler<HTMLTableDataCellElement>;
714
+ onSubmitCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
715
+ onInvalid?: React.FormEventHandler<HTMLTableDataCellElement>;
716
+ onInvalidCapture?: React.FormEventHandler<HTMLTableDataCellElement>;
717
+ onLoad?: React.ReactEventHandler<HTMLTableDataCellElement>;
718
+ onLoadCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
719
+ onError?: React.ReactEventHandler<HTMLTableDataCellElement>;
720
+ onErrorCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
721
+ onKeyDown?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
722
+ onKeyDownCapture?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
723
+ onKeyPress?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
724
+ onKeyPressCapture?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
725
+ onKeyUp?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
726
+ onKeyUpCapture?: React.KeyboardEventHandler<HTMLTableDataCellElement>;
727
+ onAbort?: React.ReactEventHandler<HTMLTableDataCellElement>;
728
+ onAbortCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
729
+ onCanPlay?: React.ReactEventHandler<HTMLTableDataCellElement>;
730
+ onCanPlayCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
731
+ onCanPlayThrough?: React.ReactEventHandler<HTMLTableDataCellElement>;
732
+ onCanPlayThroughCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
733
+ onDurationChange?: React.ReactEventHandler<HTMLTableDataCellElement>;
734
+ onDurationChangeCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
735
+ onEmptied?: React.ReactEventHandler<HTMLTableDataCellElement>;
736
+ onEmptiedCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
737
+ onEncrypted?: React.ReactEventHandler<HTMLTableDataCellElement>;
738
+ onEncryptedCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
739
+ onEnded?: React.ReactEventHandler<HTMLTableDataCellElement>;
740
+ onEndedCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
741
+ onLoadedData?: React.ReactEventHandler<HTMLTableDataCellElement>;
742
+ onLoadedDataCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
743
+ onLoadedMetadata?: React.ReactEventHandler<HTMLTableDataCellElement>;
744
+ onLoadedMetadataCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
745
+ onLoadStart?: React.ReactEventHandler<HTMLTableDataCellElement>;
746
+ onLoadStartCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
747
+ onPause?: React.ReactEventHandler<HTMLTableDataCellElement>;
748
+ onPauseCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
749
+ onPlay?: React.ReactEventHandler<HTMLTableDataCellElement>;
750
+ onPlayCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
751
+ onPlaying?: React.ReactEventHandler<HTMLTableDataCellElement>;
752
+ onPlayingCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
753
+ onProgress?: React.ReactEventHandler<HTMLTableDataCellElement>;
754
+ onProgressCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
755
+ onRateChange?: React.ReactEventHandler<HTMLTableDataCellElement>;
756
+ onRateChangeCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
757
+ onResize?: React.ReactEventHandler<HTMLTableDataCellElement>;
758
+ onResizeCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
759
+ onSeeked?: React.ReactEventHandler<HTMLTableDataCellElement>;
760
+ onSeekedCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
761
+ onSeeking?: React.ReactEventHandler<HTMLTableDataCellElement>;
762
+ onSeekingCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
763
+ onStalled?: React.ReactEventHandler<HTMLTableDataCellElement>;
764
+ onStalledCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
765
+ onSuspend?: React.ReactEventHandler<HTMLTableDataCellElement>;
766
+ onSuspendCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
767
+ onTimeUpdate?: React.ReactEventHandler<HTMLTableDataCellElement>;
768
+ onTimeUpdateCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
769
+ onVolumeChange?: React.ReactEventHandler<HTMLTableDataCellElement>;
770
+ onVolumeChangeCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
771
+ onWaiting?: React.ReactEventHandler<HTMLTableDataCellElement>;
772
+ onWaitingCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
773
+ onAuxClick?: React.MouseEventHandler<HTMLTableDataCellElement>;
774
+ onAuxClickCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
775
+ onClick?: React.MouseEventHandler<HTMLTableDataCellElement>;
776
+ onClickCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
777
+ onContextMenu?: React.MouseEventHandler<HTMLTableDataCellElement>;
778
+ onContextMenuCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
779
+ onDoubleClick?: React.MouseEventHandler<HTMLTableDataCellElement>;
780
+ onDoubleClickCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
781
+ onDrag?: React.DragEventHandler<HTMLTableDataCellElement>;
782
+ onDragCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
783
+ onDragEnd?: React.DragEventHandler<HTMLTableDataCellElement>;
784
+ onDragEndCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
785
+ onDragEnter?: React.DragEventHandler<HTMLTableDataCellElement>;
786
+ onDragEnterCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
787
+ onDragExit?: React.DragEventHandler<HTMLTableDataCellElement>;
788
+ onDragExitCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
789
+ onDragLeave?: React.DragEventHandler<HTMLTableDataCellElement>;
790
+ onDragLeaveCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
791
+ onDragOver?: React.DragEventHandler<HTMLTableDataCellElement>;
792
+ onDragOverCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
793
+ onDragStart?: React.DragEventHandler<HTMLTableDataCellElement>;
794
+ onDragStartCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
795
+ onDrop?: React.DragEventHandler<HTMLTableDataCellElement>;
796
+ onDropCapture?: React.DragEventHandler<HTMLTableDataCellElement>;
797
+ onMouseDown?: React.MouseEventHandler<HTMLTableDataCellElement>;
798
+ onMouseDownCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
799
+ onMouseEnter?: React.MouseEventHandler<HTMLTableDataCellElement>;
800
+ onMouseLeave?: React.MouseEventHandler<HTMLTableDataCellElement>;
801
+ onMouseMove?: React.MouseEventHandler<HTMLTableDataCellElement>;
802
+ onMouseMoveCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
803
+ onMouseOut?: React.MouseEventHandler<HTMLTableDataCellElement>;
804
+ onMouseOutCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
805
+ onMouseOver?: React.MouseEventHandler<HTMLTableDataCellElement>;
806
+ onMouseOverCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
807
+ onMouseUp?: React.MouseEventHandler<HTMLTableDataCellElement>;
808
+ onMouseUpCapture?: React.MouseEventHandler<HTMLTableDataCellElement>;
809
+ onSelect?: React.ReactEventHandler<HTMLTableDataCellElement>;
810
+ onSelectCapture?: React.ReactEventHandler<HTMLTableDataCellElement>;
811
+ onTouchCancel?: React.TouchEventHandler<HTMLTableDataCellElement>;
812
+ onTouchCancelCapture?: React.TouchEventHandler<HTMLTableDataCellElement>;
813
+ onTouchEnd?: React.TouchEventHandler<HTMLTableDataCellElement>;
814
+ onTouchEndCapture?: React.TouchEventHandler<HTMLTableDataCellElement>;
815
+ onTouchMove?: React.TouchEventHandler<HTMLTableDataCellElement>;
816
+ onTouchMoveCapture?: React.TouchEventHandler<HTMLTableDataCellElement>;
817
+ onTouchStart?: React.TouchEventHandler<HTMLTableDataCellElement>;
818
+ onTouchStartCapture?: React.TouchEventHandler<HTMLTableDataCellElement>;
819
+ onPointerDown?: React.PointerEventHandler<HTMLTableDataCellElement>;
820
+ onPointerDownCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
821
+ onPointerMove?: React.PointerEventHandler<HTMLTableDataCellElement>;
822
+ onPointerMoveCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
823
+ onPointerUp?: React.PointerEventHandler<HTMLTableDataCellElement>;
824
+ onPointerUpCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
825
+ onPointerCancel?: React.PointerEventHandler<HTMLTableDataCellElement>;
826
+ onPointerCancelCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
827
+ onPointerEnter?: React.PointerEventHandler<HTMLTableDataCellElement>;
828
+ onPointerEnterCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
829
+ onPointerLeave?: React.PointerEventHandler<HTMLTableDataCellElement>;
830
+ onPointerLeaveCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
831
+ onPointerOver?: React.PointerEventHandler<HTMLTableDataCellElement>;
832
+ onPointerOverCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
833
+ onPointerOut?: React.PointerEventHandler<HTMLTableDataCellElement>;
834
+ onPointerOutCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
835
+ onGotPointerCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
836
+ onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
837
+ onLostPointerCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
838
+ onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLTableDataCellElement>;
839
+ onScroll?: React.UIEventHandler<HTMLTableDataCellElement>;
840
+ onScrollCapture?: React.UIEventHandler<HTMLTableDataCellElement>;
841
+ onWheel?: React.WheelEventHandler<HTMLTableDataCellElement>;
842
+ onWheelCapture?: React.WheelEventHandler<HTMLTableDataCellElement>;
843
+ onAnimationStart?: React.AnimationEventHandler<HTMLTableDataCellElement>;
844
+ onAnimationStartCapture?: React.AnimationEventHandler<HTMLTableDataCellElement>;
845
+ onAnimationEnd?: React.AnimationEventHandler<HTMLTableDataCellElement>;
846
+ onAnimationEndCapture?: React.AnimationEventHandler<HTMLTableDataCellElement>;
847
+ onAnimationIteration?: React.AnimationEventHandler<HTMLTableDataCellElement>;
848
+ onAnimationIterationCapture?: React.AnimationEventHandler<HTMLTableDataCellElement>;
849
+ onTransitionEnd?: React.TransitionEventHandler<HTMLTableDataCellElement>;
850
+ onTransitionEndCapture?: React.TransitionEventHandler<HTMLTableDataCellElement>;
851
+ }>;
24
852
  //# sourceMappingURL=Table.d.ts.map