html/generated/
tr.rs

1pub mod element {
2    /// The HTML `<tr>` element
3    ///
4    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tr)
5    #[doc(alias = "tr")]
6    #[non_exhaustive]
7    #[derive(PartialEq, Clone, Default)]
8    pub struct TableRow {
9        sys: html_sys::tables::TableRow,
10        children: Vec<super::child::TableRowChild>,
11    }
12    impl TableRow {
13        /// Create a new builder
14        pub fn builder() -> super::builder::TableRowBuilder {
15            super::builder::TableRowBuilder::new(Default::default())
16        }
17    }
18    impl TableRow {
19        /// Access the element's `data-*` properties
20        pub fn data_map(&self) -> &html_sys::DataMap {
21            &self.sys.data_map
22        }
23        /// Mutably access the element's `data-*` properties
24        pub fn data_map_mut(&mut self) -> &mut html_sys::DataMap {
25            &mut self.sys.data_map
26        }
27    }
28    impl TableRow {
29        /// Get the value of the `role` attribute
30        pub fn role(&self) -> std::option::Option<&str> {
31            self.sys.role.as_deref()
32        }
33        /// Set the value of the `role` attribute
34        pub fn set_role(
35            &mut self,
36            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
37        ) {
38            self.sys.role = value.map(|v| v.into());
39        }
40        /// Get the value of the `aria-activedescendant` attribute
41        pub fn aria_active_descendant_element(&self) -> std::option::Option<&str> {
42            self.sys.aria_active_descendant_element.as_deref()
43        }
44        /// Set the value of the `aria-activedescendant` attribute
45        pub fn set_aria_active_descendant_element(
46            &mut self,
47            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
48        ) {
49            self.sys.aria_active_descendant_element = value.map(|v| v.into());
50        }
51        /// Get the value of the `aria-atomic` attribute
52        pub fn aria_atomic(&self) -> bool {
53            self.sys.aria_atomic
54        }
55        /// Set the value of the `aria-atomic` attribute
56        pub fn set_aria_atomic(&mut self, value: bool) {
57            self.sys.aria_atomic = value;
58        }
59        /// Get the value of the `aria-autocomplete` attribute
60        pub fn aria_auto_complete(&self) -> std::option::Option<&str> {
61            self.sys.aria_auto_complete.as_deref()
62        }
63        /// Set the value of the `aria-autocomplete` attribute
64        pub fn set_aria_auto_complete(
65            &mut self,
66            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
67        ) {
68            self.sys.aria_auto_complete = value.map(|v| v.into());
69        }
70        /// Get the value of the `aria-braillelabel` attribute
71        pub fn aria_braille_label(&self) -> std::option::Option<&str> {
72            self.sys.aria_braille_label.as_deref()
73        }
74        /// Set the value of the `aria-braillelabel` attribute
75        pub fn set_aria_braille_label(
76            &mut self,
77            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
78        ) {
79            self.sys.aria_braille_label = value.map(|v| v.into());
80        }
81        /// Get the value of the `aria-brailleroledescription` attribute
82        pub fn aria_braille_role_description(&self) -> std::option::Option<&str> {
83            self.sys.aria_braille_role_description.as_deref()
84        }
85        /// Set the value of the `aria-brailleroledescription` attribute
86        pub fn set_aria_braille_role_description(
87            &mut self,
88            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
89        ) {
90            self.sys.aria_braille_role_description = value.map(|v| v.into());
91        }
92        /// Get the value of the `aria-busy` attribute
93        pub fn aria_busy(&self) -> bool {
94            self.sys.aria_busy
95        }
96        /// Set the value of the `aria-busy` attribute
97        pub fn set_aria_busy(&mut self, value: bool) {
98            self.sys.aria_busy = value;
99        }
100        /// Get the value of the `aria-checked` attribute
101        pub fn aria_checked(&self) -> std::option::Option<&str> {
102            self.sys.aria_checked.as_deref()
103        }
104        /// Set the value of the `aria-checked` attribute
105        pub fn set_aria_checked(
106            &mut self,
107            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
108        ) {
109            self.sys.aria_checked = value.map(|v| v.into());
110        }
111        /// Get the value of the `aria-colcount` attribute
112        pub fn aria_col_count(&self) -> std::option::Option<i64> {
113            self.sys.aria_col_count
114        }
115        /// Set the value of the `aria-colcount` attribute
116        pub fn set_aria_col_count(&mut self, value: std::option::Option<i64>) {
117            self.sys.aria_col_count = value;
118        }
119        /// Get the value of the `aria-colindex` attribute
120        pub fn aria_col_index(&self) -> std::option::Option<i64> {
121            self.sys.aria_col_index
122        }
123        /// Set the value of the `aria-colindex` attribute
124        pub fn set_aria_col_index(&mut self, value: std::option::Option<i64>) {
125            self.sys.aria_col_index = value;
126        }
127        /// Get the value of the `aria-colindextext` attribute
128        pub fn aria_col_index_text(&self) -> std::option::Option<&str> {
129            self.sys.aria_col_index_text.as_deref()
130        }
131        /// Set the value of the `aria-colindextext` attribute
132        pub fn set_aria_col_index_text(
133            &mut self,
134            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
135        ) {
136            self.sys.aria_col_index_text = value.map(|v| v.into());
137        }
138        /// Get the value of the `aria-colspan` attribute
139        pub fn aria_col_span(&self) -> std::option::Option<i64> {
140            self.sys.aria_col_span
141        }
142        /// Set the value of the `aria-colspan` attribute
143        pub fn set_aria_col_span(&mut self, value: std::option::Option<i64>) {
144            self.sys.aria_col_span = value;
145        }
146        /// Get the value of the `aria-controls` attribute
147        pub fn aria_controls_elements(&self) -> std::option::Option<&str> {
148            self.sys.aria_controls_elements.as_deref()
149        }
150        /// Set the value of the `aria-controls` attribute
151        pub fn set_aria_controls_elements(
152            &mut self,
153            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
154        ) {
155            self.sys.aria_controls_elements = value.map(|v| v.into());
156        }
157        /// Get the value of the `aria-current` attribute
158        pub fn aria_current(&self) -> std::option::Option<&str> {
159            self.sys.aria_current.as_deref()
160        }
161        /// Set the value of the `aria-current` attribute
162        pub fn set_aria_current(
163            &mut self,
164            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
165        ) {
166            self.sys.aria_current = value.map(|v| v.into());
167        }
168        /// Get the value of the `aria-describedby` attribute
169        pub fn aria_described_by_elements(&self) -> std::option::Option<&str> {
170            self.sys.aria_described_by_elements.as_deref()
171        }
172        /// Set the value of the `aria-describedby` attribute
173        pub fn set_aria_described_by_elements(
174            &mut self,
175            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
176        ) {
177            self.sys.aria_described_by_elements = value.map(|v| v.into());
178        }
179        /// Get the value of the `aria-description` attribute
180        pub fn aria_description(&self) -> std::option::Option<&str> {
181            self.sys.aria_description.as_deref()
182        }
183        /// Set the value of the `aria-description` attribute
184        pub fn set_aria_description(
185            &mut self,
186            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
187        ) {
188            self.sys.aria_description = value.map(|v| v.into());
189        }
190        /// Get the value of the `aria-details` attribute
191        pub fn aria_details_elements(&self) -> std::option::Option<&str> {
192            self.sys.aria_details_elements.as_deref()
193        }
194        /// Set the value of the `aria-details` attribute
195        pub fn set_aria_details_elements(
196            &mut self,
197            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
198        ) {
199            self.sys.aria_details_elements = value.map(|v| v.into());
200        }
201        /// Get the value of the `aria-disabled` attribute
202        pub fn aria_disabled(&self) -> bool {
203            self.sys.aria_disabled
204        }
205        /// Set the value of the `aria-disabled` attribute
206        pub fn set_aria_disabled(&mut self, value: bool) {
207            self.sys.aria_disabled = value;
208        }
209        /// Get the value of the `aria-dropeffect` attribute
210        pub fn aria_drop_effect(&self) -> std::option::Option<&str> {
211            self.sys.aria_drop_effect.as_deref()
212        }
213        /// Set the value of the `aria-dropeffect` attribute
214        pub fn set_aria_drop_effect(
215            &mut self,
216            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
217        ) {
218            self.sys.aria_drop_effect = value.map(|v| v.into());
219        }
220        /// Get the value of the `aria-errormessage` attribute
221        pub fn aria_error_message_elements(&self) -> std::option::Option<&str> {
222            self.sys.aria_error_message_elements.as_deref()
223        }
224        /// Set the value of the `aria-errormessage` attribute
225        pub fn set_aria_error_message_elements(
226            &mut self,
227            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
228        ) {
229            self.sys.aria_error_message_elements = value.map(|v| v.into());
230        }
231        /// Get the value of the `aria-expanded` attribute
232        pub fn aria_expanded(&self) -> bool {
233            self.sys.aria_expanded
234        }
235        /// Set the value of the `aria-expanded` attribute
236        pub fn set_aria_expanded(&mut self, value: bool) {
237            self.sys.aria_expanded = value;
238        }
239        /// Get the value of the `aria-flowto` attribute
240        pub fn aria_flow_to_elements(&self) -> std::option::Option<&str> {
241            self.sys.aria_flow_to_elements.as_deref()
242        }
243        /// Set the value of the `aria-flowto` attribute
244        pub fn set_aria_flow_to_elements(
245            &mut self,
246            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
247        ) {
248            self.sys.aria_flow_to_elements = value.map(|v| v.into());
249        }
250        /// Get the value of the `aria-grabbed` attribute
251        pub fn aria_grabbed(&self) -> bool {
252            self.sys.aria_grabbed
253        }
254        /// Set the value of the `aria-grabbed` attribute
255        pub fn set_aria_grabbed(&mut self, value: bool) {
256            self.sys.aria_grabbed = value;
257        }
258        /// Get the value of the `aria-haspopup` attribute
259        pub fn aria_has_popup(&self) -> std::option::Option<&str> {
260            self.sys.aria_has_popup.as_deref()
261        }
262        /// Set the value of the `aria-haspopup` attribute
263        pub fn set_aria_has_popup(
264            &mut self,
265            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
266        ) {
267            self.sys.aria_has_popup = value.map(|v| v.into());
268        }
269        /// Get the value of the `aria-hidden` attribute
270        pub fn aria_hidden(&self) -> bool {
271            self.sys.aria_hidden
272        }
273        /// Set the value of the `aria-hidden` attribute
274        pub fn set_aria_hidden(&mut self, value: bool) {
275            self.sys.aria_hidden = value;
276        }
277        /// Get the value of the `aria-invalid` attribute
278        pub fn aria_invalid(&self) -> std::option::Option<&str> {
279            self.sys.aria_invalid.as_deref()
280        }
281        /// Set the value of the `aria-invalid` attribute
282        pub fn set_aria_invalid(
283            &mut self,
284            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
285        ) {
286            self.sys.aria_invalid = value.map(|v| v.into());
287        }
288        /// Get the value of the `aria-keyshortcuts` attribute
289        pub fn aria_key_shortcuts(&self) -> std::option::Option<&str> {
290            self.sys.aria_key_shortcuts.as_deref()
291        }
292        /// Set the value of the `aria-keyshortcuts` attribute
293        pub fn set_aria_key_shortcuts(
294            &mut self,
295            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
296        ) {
297            self.sys.aria_key_shortcuts = value.map(|v| v.into());
298        }
299        /// Get the value of the `aria-label` attribute
300        pub fn aria_label(&self) -> std::option::Option<&str> {
301            self.sys.aria_label.as_deref()
302        }
303        /// Set the value of the `aria-label` attribute
304        pub fn set_aria_label(
305            &mut self,
306            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
307        ) {
308            self.sys.aria_label = value.map(|v| v.into());
309        }
310        /// Get the value of the `aria-labelledby` attribute
311        pub fn aria_labelled_by_elements(&self) -> std::option::Option<&str> {
312            self.sys.aria_labelled_by_elements.as_deref()
313        }
314        /// Set the value of the `aria-labelledby` attribute
315        pub fn set_aria_labelled_by_elements(
316            &mut self,
317            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
318        ) {
319            self.sys.aria_labelled_by_elements = value.map(|v| v.into());
320        }
321        /// Get the value of the `aria-level` attribute
322        pub fn aria_level(&self) -> std::option::Option<i64> {
323            self.sys.aria_level
324        }
325        /// Set the value of the `aria-level` attribute
326        pub fn set_aria_level(&mut self, value: std::option::Option<i64>) {
327            self.sys.aria_level = value;
328        }
329        /// Get the value of the `aria-live` attribute
330        pub fn aria_live(&self) -> std::option::Option<&str> {
331            self.sys.aria_live.as_deref()
332        }
333        /// Set the value of the `aria-live` attribute
334        pub fn set_aria_live(
335            &mut self,
336            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
337        ) {
338            self.sys.aria_live = value.map(|v| v.into());
339        }
340        /// Get the value of the `aria-modal` attribute
341        pub fn aria_modal(&self) -> bool {
342            self.sys.aria_modal
343        }
344        /// Set the value of the `aria-modal` attribute
345        pub fn set_aria_modal(&mut self, value: bool) {
346            self.sys.aria_modal = value;
347        }
348        /// Get the value of the `aria-multiline` attribute
349        pub fn aria_multi_line(&self) -> bool {
350            self.sys.aria_multi_line
351        }
352        /// Set the value of the `aria-multiline` attribute
353        pub fn set_aria_multi_line(&mut self, value: bool) {
354            self.sys.aria_multi_line = value;
355        }
356        /// Get the value of the `aria-multiselectable` attribute
357        pub fn aria_multi_selectable(&self) -> bool {
358            self.sys.aria_multi_selectable
359        }
360        /// Set the value of the `aria-multiselectable` attribute
361        pub fn set_aria_multi_selectable(&mut self, value: bool) {
362            self.sys.aria_multi_selectable = value;
363        }
364        /// Get the value of the `aria-orientation` attribute
365        pub fn aria_orientation(&self) -> std::option::Option<&str> {
366            self.sys.aria_orientation.as_deref()
367        }
368        /// Set the value of the `aria-orientation` attribute
369        pub fn set_aria_orientation(
370            &mut self,
371            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
372        ) {
373            self.sys.aria_orientation = value.map(|v| v.into());
374        }
375        /// Get the value of the `aria-owns` attribute
376        pub fn aria_owns_elements(&self) -> std::option::Option<&str> {
377            self.sys.aria_owns_elements.as_deref()
378        }
379        /// Set the value of the `aria-owns` attribute
380        pub fn set_aria_owns_elements(
381            &mut self,
382            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
383        ) {
384            self.sys.aria_owns_elements = value.map(|v| v.into());
385        }
386        /// Get the value of the `aria-placeholder` attribute
387        pub fn aria_placeholder(&self) -> std::option::Option<&str> {
388            self.sys.aria_placeholder.as_deref()
389        }
390        /// Set the value of the `aria-placeholder` attribute
391        pub fn set_aria_placeholder(
392            &mut self,
393            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
394        ) {
395            self.sys.aria_placeholder = value.map(|v| v.into());
396        }
397        /// Get the value of the `aria-posinset` attribute
398        pub fn aria_pos_in_set(&self) -> std::option::Option<i64> {
399            self.sys.aria_pos_in_set
400        }
401        /// Set the value of the `aria-posinset` attribute
402        pub fn set_aria_pos_in_set(&mut self, value: std::option::Option<i64>) {
403            self.sys.aria_pos_in_set = value;
404        }
405        /// Get the value of the `aria-pressed` attribute
406        pub fn aria_pressed(&self) -> std::option::Option<&str> {
407            self.sys.aria_pressed.as_deref()
408        }
409        /// Set the value of the `aria-pressed` attribute
410        pub fn set_aria_pressed(
411            &mut self,
412            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
413        ) {
414            self.sys.aria_pressed = value.map(|v| v.into());
415        }
416        /// Get the value of the `aria-readonly` attribute
417        pub fn aria_read_only(&self) -> bool {
418            self.sys.aria_read_only
419        }
420        /// Set the value of the `aria-readonly` attribute
421        pub fn set_aria_read_only(&mut self, value: bool) {
422            self.sys.aria_read_only = value;
423        }
424        /// Get the value of the `aria-relevant` attribute
425        pub fn aria_relevant(&self) -> std::option::Option<&str> {
426            self.sys.aria_relevant.as_deref()
427        }
428        /// Set the value of the `aria-relevant` attribute
429        pub fn set_aria_relevant(
430            &mut self,
431            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
432        ) {
433            self.sys.aria_relevant = value.map(|v| v.into());
434        }
435        /// Get the value of the `aria-required` attribute
436        pub fn aria_required(&self) -> bool {
437            self.sys.aria_required
438        }
439        /// Set the value of the `aria-required` attribute
440        pub fn set_aria_required(&mut self, value: bool) {
441            self.sys.aria_required = value;
442        }
443        /// Get the value of the `aria-roledescription` attribute
444        pub fn aria_role_description(&self) -> std::option::Option<&str> {
445            self.sys.aria_role_description.as_deref()
446        }
447        /// Set the value of the `aria-roledescription` attribute
448        pub fn set_aria_role_description(
449            &mut self,
450            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
451        ) {
452            self.sys.aria_role_description = value.map(|v| v.into());
453        }
454        /// Get the value of the `aria-rowcount` attribute
455        pub fn aria_row_count(&self) -> std::option::Option<i64> {
456            self.sys.aria_row_count
457        }
458        /// Set the value of the `aria-rowcount` attribute
459        pub fn set_aria_row_count(&mut self, value: std::option::Option<i64>) {
460            self.sys.aria_row_count = value;
461        }
462        /// Get the value of the `aria-rowindex` attribute
463        pub fn aria_row_index(&self) -> std::option::Option<i64> {
464            self.sys.aria_row_index
465        }
466        /// Set the value of the `aria-rowindex` attribute
467        pub fn set_aria_row_index(&mut self, value: std::option::Option<i64>) {
468            self.sys.aria_row_index = value;
469        }
470        /// Get the value of the `aria-rowindextext` attribute
471        pub fn aria_row_index_text(&self) -> std::option::Option<&str> {
472            self.sys.aria_row_index_text.as_deref()
473        }
474        /// Set the value of the `aria-rowindextext` attribute
475        pub fn set_aria_row_index_text(
476            &mut self,
477            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
478        ) {
479            self.sys.aria_row_index_text = value.map(|v| v.into());
480        }
481        /// Get the value of the `aria-rowspan` attribute
482        pub fn aria_row_span(&self) -> std::option::Option<i64> {
483            self.sys.aria_row_span
484        }
485        /// Set the value of the `aria-rowspan` attribute
486        pub fn set_aria_row_span(&mut self, value: std::option::Option<i64>) {
487            self.sys.aria_row_span = value;
488        }
489        /// Get the value of the `aria-selected` attribute
490        pub fn aria_selected(&self) -> bool {
491            self.sys.aria_selected
492        }
493        /// Set the value of the `aria-selected` attribute
494        pub fn set_aria_selected(&mut self, value: bool) {
495            self.sys.aria_selected = value;
496        }
497        /// Get the value of the `aria-setsize` attribute
498        pub fn aria_set_size(&self) -> std::option::Option<i64> {
499            self.sys.aria_set_size
500        }
501        /// Set the value of the `aria-setsize` attribute
502        pub fn set_aria_set_size(&mut self, value: std::option::Option<i64>) {
503            self.sys.aria_set_size = value;
504        }
505        /// Get the value of the `aria-sort` attribute
506        pub fn aria_sort(&self) -> std::option::Option<&str> {
507            self.sys.aria_sort.as_deref()
508        }
509        /// Set the value of the `aria-sort` attribute
510        pub fn set_aria_sort(
511            &mut self,
512            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
513        ) {
514            self.sys.aria_sort = value.map(|v| v.into());
515        }
516        /// Get the value of the `aria-valuemax` attribute
517        pub fn aria_value_max(&self) -> std::option::Option<f64> {
518            self.sys.aria_value_max
519        }
520        /// Set the value of the `aria-valuemax` attribute
521        pub fn set_aria_value_max(&mut self, value: std::option::Option<f64>) {
522            self.sys.aria_value_max = value;
523        }
524        /// Get the value of the `aria-valuemin` attribute
525        pub fn aria_value_min(&self) -> std::option::Option<f64> {
526            self.sys.aria_value_min
527        }
528        /// Set the value of the `aria-valuemin` attribute
529        pub fn set_aria_value_min(&mut self, value: std::option::Option<f64>) {
530            self.sys.aria_value_min = value;
531        }
532        /// Get the value of the `aria-valuenow` attribute
533        pub fn aria_value_now(&self) -> std::option::Option<f64> {
534            self.sys.aria_value_now
535        }
536        /// Set the value of the `aria-valuenow` attribute
537        pub fn set_aria_value_now(&mut self, value: std::option::Option<f64>) {
538            self.sys.aria_value_now = value;
539        }
540        /// Get the value of the `aria-valuetext` attribute
541        pub fn aria_value_text(&self) -> std::option::Option<&str> {
542            self.sys.aria_value_text.as_deref()
543        }
544        /// Set the value of the `aria-valuetext` attribute
545        pub fn set_aria_value_text(
546            &mut self,
547            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
548        ) {
549            self.sys.aria_value_text = value.map(|v| v.into());
550        }
551        /// Get the value of the `accesskey` attribute
552        pub fn access_key(&self) -> std::option::Option<&str> {
553            self.sys.access_key.as_deref()
554        }
555        /// Set the value of the `accesskey` attribute
556        pub fn set_access_key(
557            &mut self,
558            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
559        ) {
560            self.sys.access_key = value.map(|v| v.into());
561        }
562        /// Get the value of the `autocapitalize` attribute
563        pub fn auto_capitalize(&self) -> std::option::Option<&str> {
564            self.sys.auto_capitalize.as_deref()
565        }
566        /// Set the value of the `autocapitalize` attribute
567        pub fn set_auto_capitalize(
568            &mut self,
569            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
570        ) {
571            self.sys.auto_capitalize = value.map(|v| v.into());
572        }
573        /// Get the value of the `autofocus` attribute
574        pub fn autofocus(&self) -> bool {
575            self.sys.autofocus
576        }
577        /// Set the value of the `autofocus` attribute
578        pub fn set_autofocus(&mut self, value: bool) {
579            self.sys.autofocus = value;
580        }
581        /// Get the value of the `class` attribute
582        pub fn class(&self) -> std::option::Option<&str> {
583            self.sys.class.as_deref()
584        }
585        /// Set the value of the `class` attribute
586        pub fn set_class(
587            &mut self,
588            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
589        ) {
590            self.sys.class = value.map(|v| v.into());
591        }
592        /// Get the value of the `contenteditable` attribute
593        pub fn content_editable(&self) -> std::option::Option<&str> {
594            self.sys.content_editable.as_deref()
595        }
596        /// Set the value of the `contenteditable` attribute
597        pub fn set_content_editable(
598            &mut self,
599            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
600        ) {
601            self.sys.content_editable = value.map(|v| v.into());
602        }
603        /// Get the value of the `dir` attribute
604        pub fn direction(&self) -> std::option::Option<&str> {
605            self.sys.direction.as_deref()
606        }
607        /// Set the value of the `dir` attribute
608        pub fn set_direction(
609            &mut self,
610            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
611        ) {
612            self.sys.direction = value.map(|v| v.into());
613        }
614        /// Get the value of the `draggable` attribute
615        pub fn draggable(&self) -> bool {
616            self.sys.draggable
617        }
618        /// Set the value of the `draggable` attribute
619        pub fn set_draggable(&mut self, value: bool) {
620            self.sys.draggable = value;
621        }
622        /// Get the value of the `enterkeyhint` attribute
623        pub fn enter_key_hint(&self) -> std::option::Option<&str> {
624            self.sys.enter_key_hint.as_deref()
625        }
626        /// Set the value of the `enterkeyhint` attribute
627        pub fn set_enter_key_hint(
628            &mut self,
629            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
630        ) {
631            self.sys.enter_key_hint = value.map(|v| v.into());
632        }
633        /// Get the value of the `exportparts` attribute
634        pub fn export_parts(&self) -> std::option::Option<&str> {
635            self.sys.export_parts.as_deref()
636        }
637        /// Set the value of the `exportparts` attribute
638        pub fn set_export_parts(
639            &mut self,
640            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
641        ) {
642            self.sys.export_parts = value.map(|v| v.into());
643        }
644        /// Get the value of the `hidden` attribute
645        pub fn hidden(&self) -> std::option::Option<&str> {
646            self.sys.hidden.as_deref()
647        }
648        /// Set the value of the `hidden` attribute
649        pub fn set_hidden(
650            &mut self,
651            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
652        ) {
653            self.sys.hidden = value.map(|v| v.into());
654        }
655        /// Get the value of the `id` attribute
656        pub fn id(&self) -> std::option::Option<&str> {
657            self.sys.id.as_deref()
658        }
659        /// Set the value of the `id` attribute
660        pub fn set_id(
661            &mut self,
662            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
663        ) {
664            self.sys.id = value.map(|v| v.into());
665        }
666        /// Get the value of the `inert` attribute
667        pub fn inert(&self) -> bool {
668            self.sys.inert
669        }
670        /// Set the value of the `inert` attribute
671        pub fn set_inert(&mut self, value: bool) {
672            self.sys.inert = value;
673        }
674        /// Get the value of the `inputmode` attribute
675        pub fn input_mode(&self) -> std::option::Option<&str> {
676            self.sys.input_mode.as_deref()
677        }
678        /// Set the value of the `inputmode` attribute
679        pub fn set_input_mode(
680            &mut self,
681            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
682        ) {
683            self.sys.input_mode = value.map(|v| v.into());
684        }
685        /// Get the value of the `is` attribute
686        pub fn is_(&self) -> std::option::Option<&str> {
687            self.sys.is_.as_deref()
688        }
689        /// Set the value of the `is` attribute
690        pub fn set_is_(
691            &mut self,
692            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
693        ) {
694            self.sys.is_ = value.map(|v| v.into());
695        }
696        /// Get the value of the `itemid` attribute
697        pub fn item_id(&self) -> std::option::Option<&str> {
698            self.sys.item_id.as_deref()
699        }
700        /// Set the value of the `itemid` attribute
701        pub fn set_item_id(
702            &mut self,
703            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
704        ) {
705            self.sys.item_id = value.map(|v| v.into());
706        }
707        /// Get the value of the `itemprop` attribute
708        pub fn item_prop(&self) -> std::option::Option<&str> {
709            self.sys.item_prop.as_deref()
710        }
711        /// Set the value of the `itemprop` attribute
712        pub fn set_item_prop(
713            &mut self,
714            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
715        ) {
716            self.sys.item_prop = value.map(|v| v.into());
717        }
718        /// Get the value of the `itemref` attribute
719        pub fn item_ref(&self) -> std::option::Option<&str> {
720            self.sys.item_ref.as_deref()
721        }
722        /// Set the value of the `itemref` attribute
723        pub fn set_item_ref(
724            &mut self,
725            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
726        ) {
727            self.sys.item_ref = value.map(|v| v.into());
728        }
729        /// Get the value of the `itemscope` attribute
730        pub fn item_scope(&self) -> std::option::Option<&str> {
731            self.sys.item_scope.as_deref()
732        }
733        /// Set the value of the `itemscope` attribute
734        pub fn set_item_scope(
735            &mut self,
736            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
737        ) {
738            self.sys.item_scope = value.map(|v| v.into());
739        }
740        /// Get the value of the `itemtype` attribute
741        pub fn item_type(&self) -> std::option::Option<&str> {
742            self.sys.item_type.as_deref()
743        }
744        /// Set the value of the `itemtype` attribute
745        pub fn set_item_type(
746            &mut self,
747            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
748        ) {
749            self.sys.item_type = value.map(|v| v.into());
750        }
751        /// Get the value of the `lang` attribute
752        pub fn lang(&self) -> std::option::Option<&str> {
753            self.sys.lang.as_deref()
754        }
755        /// Set the value of the `lang` attribute
756        pub fn set_lang(
757            &mut self,
758            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
759        ) {
760            self.sys.lang = value.map(|v| v.into());
761        }
762        /// Get the value of the `nonce` attribute
763        pub fn nonce(&self) -> std::option::Option<&str> {
764            self.sys.nonce.as_deref()
765        }
766        /// Set the value of the `nonce` attribute
767        pub fn set_nonce(
768            &mut self,
769            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
770        ) {
771            self.sys.nonce = value.map(|v| v.into());
772        }
773        /// Get the value of the `part` attribute
774        pub fn part(&self) -> std::option::Option<&str> {
775            self.sys.part.as_deref()
776        }
777        /// Set the value of the `part` attribute
778        pub fn set_part(
779            &mut self,
780            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
781        ) {
782            self.sys.part = value.map(|v| v.into());
783        }
784        /// Get the value of the `slot` attribute
785        pub fn slot(&self) -> std::option::Option<&str> {
786            self.sys.slot.as_deref()
787        }
788        /// Set the value of the `slot` attribute
789        pub fn set_slot(
790            &mut self,
791            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
792        ) {
793            self.sys.slot = value.map(|v| v.into());
794        }
795        /// Get the value of the `spellcheck` attribute
796        pub fn spellcheck(&self) -> std::option::Option<&str> {
797            self.sys.spellcheck.as_deref()
798        }
799        /// Set the value of the `spellcheck` attribute
800        pub fn set_spellcheck(
801            &mut self,
802            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
803        ) {
804            self.sys.spellcheck = value.map(|v| v.into());
805        }
806        /// Get the value of the `style` attribute
807        pub fn style(&self) -> std::option::Option<&str> {
808            self.sys.style.as_deref()
809        }
810        /// Set the value of the `style` attribute
811        pub fn set_style(
812            &mut self,
813            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
814        ) {
815            self.sys.style = value.map(|v| v.into());
816        }
817        /// Get the value of the `tabindex` attribute
818        pub fn tab_index(&self) -> std::option::Option<i64> {
819            self.sys.tab_index
820        }
821        /// Set the value of the `tabindex` attribute
822        pub fn set_tab_index(&mut self, value: std::option::Option<i64>) {
823            self.sys.tab_index = value;
824        }
825        /// Get the value of the `title` attribute
826        pub fn title(&self) -> std::option::Option<&str> {
827            self.sys.title.as_deref()
828        }
829        /// Set the value of the `title` attribute
830        pub fn set_title(
831            &mut self,
832            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
833        ) {
834            self.sys.title = value.map(|v| v.into());
835        }
836        /// Get the value of the `translate` attribute
837        pub fn translate(&self) -> bool {
838            self.sys.translate
839        }
840        /// Set the value of the `translate` attribute
841        pub fn set_translate(&mut self, value: bool) {
842            self.sys.translate = value;
843        }
844    }
845    impl TableRow {
846        /// Access the element's children
847        pub fn children(&self) -> &[super::child::TableRowChild] {
848            self.children.as_ref()
849        }
850        /// Mutably access the element's children
851        pub fn children_mut(&mut self) -> &mut Vec<super::child::TableRowChild> {
852            &mut self.children
853        }
854    }
855    impl crate::Render for TableRow {
856        fn render(
857            &self,
858            f: &mut std::fmt::Formatter<'_>,
859            depth: usize,
860        ) -> std::fmt::Result {
861            write!(f, "{:level$}", "", level = depth * 4)?;
862            html_sys::RenderElement::write_opening_tag(&self.sys, f)?;
863            if !self.children.is_empty() {
864                write!(f, "\n")?;
865            }
866            for el in &self.children {
867                crate::Render::render(&el, f, depth)?;
868                write!(f, "\n")?;
869            }
870            write!(f, "{:level$}", "", level = depth * 4)?;
871            html_sys::RenderElement::write_closing_tag(&self.sys, f)?;
872            Ok(())
873        }
874    }
875    impl std::fmt::Debug for TableRow {
876        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
877            crate::Render::render(self, f, 0)?;
878            Ok(())
879        }
880    }
881    impl std::fmt::Display for TableRow {
882        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
883            html_sys::RenderElement::write_opening_tag(&self.sys, f)?;
884            for el in &self.children {
885                write!(f, "{el}")?;
886            }
887            html_sys::RenderElement::write_closing_tag(&self.sys, f)?;
888            Ok(())
889        }
890    }
891    impl crate::HtmlElement for TableRow {}
892    impl std::convert::Into<html_sys::tables::TableRow> for TableRow {
893        fn into(self) -> html_sys::tables::TableRow {
894            self.sys
895        }
896    }
897    impl From<html_sys::tables::TableRow> for TableRow {
898        fn from(sys: html_sys::tables::TableRow) -> Self {
899            Self { sys, children: vec![] }
900        }
901    }
902}
903pub mod child {
904    /// The permitted child items for the `TableRow` element
905    #[derive(PartialEq, Clone)]
906    pub enum TableRowChild {
907        /// The Script element
908        Script(crate::generated::all::Script),
909        /// The TableCell element
910        TableCell(crate::generated::all::TableCell),
911        /// The TableHeader element
912        TableHeader(crate::generated::all::TableHeader),
913        /// The Template element
914        Template(crate::generated::all::Template),
915    }
916    impl std::convert::From<crate::generated::all::Script> for TableRowChild {
917        fn from(value: crate::generated::all::Script) -> Self {
918            Self::Script(value)
919        }
920    }
921    impl std::convert::From<crate::generated::all::TableCell> for TableRowChild {
922        fn from(value: crate::generated::all::TableCell) -> Self {
923            Self::TableCell(value)
924        }
925    }
926    impl std::convert::From<crate::generated::all::TableHeader> for TableRowChild {
927        fn from(value: crate::generated::all::TableHeader) -> Self {
928            Self::TableHeader(value)
929        }
930    }
931    impl std::convert::From<crate::generated::all::Template> for TableRowChild {
932        fn from(value: crate::generated::all::Template) -> Self {
933            Self::Template(value)
934        }
935    }
936    impl crate::Render for TableRowChild {
937        fn render(
938            &self,
939            f: &mut std::fmt::Formatter<'_>,
940            depth: usize,
941        ) -> std::fmt::Result {
942            match self {
943                Self::Script(el) => crate::Render::render(el, f, depth + 1),
944                Self::TableCell(el) => crate::Render::render(el, f, depth + 1),
945                Self::TableHeader(el) => crate::Render::render(el, f, depth + 1),
946                Self::Template(el) => crate::Render::render(el, f, depth + 1),
947            }
948        }
949    }
950    impl std::fmt::Debug for TableRowChild {
951        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
952            crate::Render::render(self, f, 0)?;
953            Ok(())
954        }
955    }
956    impl std::fmt::Display for TableRowChild {
957        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
958            match self {
959                Self::Script(el) => write!(f, "{el}"),
960                Self::TableCell(el) => write!(f, "{el}"),
961                Self::TableHeader(el) => write!(f, "{el}"),
962                Self::Template(el) => write!(f, "{el}"),
963            }
964        }
965    }
966}
967pub mod builder {
968    /// A builder struct for TableRow
969    pub struct TableRowBuilder {
970        element: super::element::TableRow,
971    }
972    impl TableRowBuilder {
973        pub(crate) fn new(element: super::element::TableRow) -> Self {
974            Self { element }
975        }
976        /// Finish building the element
977        pub fn build(&mut self) -> super::element::TableRow {
978            self.element.clone()
979        }
980        /// Insert a `data-*` property
981        pub fn data(
982            &mut self,
983            data_key: impl Into<std::borrow::Cow<'static, str>>,
984            value: impl Into<std::borrow::Cow<'static, str>>,
985        ) -> &mut TableRowBuilder {
986            self.element.data_map_mut().insert(data_key.into(), value.into());
987            self
988        }
989        /// Append a new `Script` element
990        pub fn script<F>(&mut self, f: F) -> &mut Self
991        where
992            F: for<'a> FnOnce(
993                &'a mut crate::generated::all::builders::ScriptBuilder,
994            ) -> &'a mut crate::generated::all::builders::ScriptBuilder,
995        {
996            let ty: crate::generated::all::Script = Default::default();
997            let mut ty_builder = crate::generated::all::builders::ScriptBuilder::new(ty);
998            (f)(&mut ty_builder);
999            let ty = ty_builder.build();
1000            self.element.children_mut().push(ty.into());
1001            self
1002        }
1003        /// Append a new `TableCell` element
1004        pub fn table_cell<F>(&mut self, f: F) -> &mut Self
1005        where
1006            F: for<'a> FnOnce(
1007                &'a mut crate::generated::all::builders::TableCellBuilder,
1008            ) -> &'a mut crate::generated::all::builders::TableCellBuilder,
1009        {
1010            let ty: crate::generated::all::TableCell = Default::default();
1011            let mut ty_builder = crate::generated::all::builders::TableCellBuilder::new(
1012                ty,
1013            );
1014            (f)(&mut ty_builder);
1015            let ty = ty_builder.build();
1016            self.element.children_mut().push(ty.into());
1017            self
1018        }
1019        /// Append a new `TableHeader` element
1020        pub fn table_header<F>(&mut self, f: F) -> &mut Self
1021        where
1022            F: for<'a> FnOnce(
1023                &'a mut crate::generated::all::builders::TableHeaderBuilder,
1024            ) -> &'a mut crate::generated::all::builders::TableHeaderBuilder,
1025        {
1026            let ty: crate::generated::all::TableHeader = Default::default();
1027            let mut ty_builder = crate::generated::all::builders::TableHeaderBuilder::new(
1028                ty,
1029            );
1030            (f)(&mut ty_builder);
1031            let ty = ty_builder.build();
1032            self.element.children_mut().push(ty.into());
1033            self
1034        }
1035        /// Append a new `Template` element
1036        pub fn template<F>(&mut self, f: F) -> &mut Self
1037        where
1038            F: for<'a> FnOnce(
1039                &'a mut crate::generated::all::builders::TemplateBuilder,
1040            ) -> &'a mut crate::generated::all::builders::TemplateBuilder,
1041        {
1042            let ty: crate::generated::all::Template = Default::default();
1043            let mut ty_builder = crate::generated::all::builders::TemplateBuilder::new(
1044                ty,
1045            );
1046            (f)(&mut ty_builder);
1047            let ty = ty_builder.build();
1048            self.element.children_mut().push(ty.into());
1049            self
1050        }
1051        /// Set the value of the `role` attribute
1052        pub fn role(
1053            &mut self,
1054            value: impl Into<std::borrow::Cow<'static, str>>,
1055        ) -> &mut Self {
1056            self.element.set_role(Some(value.into()));
1057            self
1058        }
1059        /// Set the value of the `aria-activedescendant` attribute
1060        pub fn aria_active_descendant_element(
1061            &mut self,
1062            value: impl Into<std::borrow::Cow<'static, str>>,
1063        ) -> &mut Self {
1064            self.element.set_aria_active_descendant_element(Some(value.into()));
1065            self
1066        }
1067        /// Set the value of the `aria-atomic` attribute
1068        pub fn aria_atomic(&mut self, value: bool) -> &mut Self {
1069            self.element.set_aria_atomic(value);
1070            self
1071        }
1072        /// Set the value of the `aria-autocomplete` attribute
1073        pub fn aria_auto_complete(
1074            &mut self,
1075            value: impl Into<std::borrow::Cow<'static, str>>,
1076        ) -> &mut Self {
1077            self.element.set_aria_auto_complete(Some(value.into()));
1078            self
1079        }
1080        /// Set the value of the `aria-braillelabel` attribute
1081        pub fn aria_braille_label(
1082            &mut self,
1083            value: impl Into<std::borrow::Cow<'static, str>>,
1084        ) -> &mut Self {
1085            self.element.set_aria_braille_label(Some(value.into()));
1086            self
1087        }
1088        /// Set the value of the `aria-brailleroledescription` attribute
1089        pub fn aria_braille_role_description(
1090            &mut self,
1091            value: impl Into<std::borrow::Cow<'static, str>>,
1092        ) -> &mut Self {
1093            self.element.set_aria_braille_role_description(Some(value.into()));
1094            self
1095        }
1096        /// Set the value of the `aria-busy` attribute
1097        pub fn aria_busy(&mut self, value: bool) -> &mut Self {
1098            self.element.set_aria_busy(value);
1099            self
1100        }
1101        /// Set the value of the `aria-checked` attribute
1102        pub fn aria_checked(
1103            &mut self,
1104            value: impl Into<std::borrow::Cow<'static, str>>,
1105        ) -> &mut Self {
1106            self.element.set_aria_checked(Some(value.into()));
1107            self
1108        }
1109        /// Set the value of the `aria-colcount` attribute
1110        pub fn aria_col_count(&mut self, value: i64) -> &mut Self {
1111            self.element.set_aria_col_count(Some(value));
1112            self
1113        }
1114        /// Set the value of the `aria-colindex` attribute
1115        pub fn aria_col_index(&mut self, value: i64) -> &mut Self {
1116            self.element.set_aria_col_index(Some(value));
1117            self
1118        }
1119        /// Set the value of the `aria-colindextext` attribute
1120        pub fn aria_col_index_text(
1121            &mut self,
1122            value: impl Into<std::borrow::Cow<'static, str>>,
1123        ) -> &mut Self {
1124            self.element.set_aria_col_index_text(Some(value.into()));
1125            self
1126        }
1127        /// Set the value of the `aria-colspan` attribute
1128        pub fn aria_col_span(&mut self, value: i64) -> &mut Self {
1129            self.element.set_aria_col_span(Some(value));
1130            self
1131        }
1132        /// Set the value of the `aria-controls` attribute
1133        pub fn aria_controls_elements(
1134            &mut self,
1135            value: impl Into<std::borrow::Cow<'static, str>>,
1136        ) -> &mut Self {
1137            self.element.set_aria_controls_elements(Some(value.into()));
1138            self
1139        }
1140        /// Set the value of the `aria-current` attribute
1141        pub fn aria_current(
1142            &mut self,
1143            value: impl Into<std::borrow::Cow<'static, str>>,
1144        ) -> &mut Self {
1145            self.element.set_aria_current(Some(value.into()));
1146            self
1147        }
1148        /// Set the value of the `aria-describedby` attribute
1149        pub fn aria_described_by_elements(
1150            &mut self,
1151            value: impl Into<std::borrow::Cow<'static, str>>,
1152        ) -> &mut Self {
1153            self.element.set_aria_described_by_elements(Some(value.into()));
1154            self
1155        }
1156        /// Set the value of the `aria-description` attribute
1157        pub fn aria_description(
1158            &mut self,
1159            value: impl Into<std::borrow::Cow<'static, str>>,
1160        ) -> &mut Self {
1161            self.element.set_aria_description(Some(value.into()));
1162            self
1163        }
1164        /// Set the value of the `aria-details` attribute
1165        pub fn aria_details_elements(
1166            &mut self,
1167            value: impl Into<std::borrow::Cow<'static, str>>,
1168        ) -> &mut Self {
1169            self.element.set_aria_details_elements(Some(value.into()));
1170            self
1171        }
1172        /// Set the value of the `aria-disabled` attribute
1173        pub fn aria_disabled(&mut self, value: bool) -> &mut Self {
1174            self.element.set_aria_disabled(value);
1175            self
1176        }
1177        /// Set the value of the `aria-dropeffect` attribute
1178        pub fn aria_drop_effect(
1179            &mut self,
1180            value: impl Into<std::borrow::Cow<'static, str>>,
1181        ) -> &mut Self {
1182            self.element.set_aria_drop_effect(Some(value.into()));
1183            self
1184        }
1185        /// Set the value of the `aria-errormessage` attribute
1186        pub fn aria_error_message_elements(
1187            &mut self,
1188            value: impl Into<std::borrow::Cow<'static, str>>,
1189        ) -> &mut Self {
1190            self.element.set_aria_error_message_elements(Some(value.into()));
1191            self
1192        }
1193        /// Set the value of the `aria-expanded` attribute
1194        pub fn aria_expanded(&mut self, value: bool) -> &mut Self {
1195            self.element.set_aria_expanded(value);
1196            self
1197        }
1198        /// Set the value of the `aria-flowto` attribute
1199        pub fn aria_flow_to_elements(
1200            &mut self,
1201            value: impl Into<std::borrow::Cow<'static, str>>,
1202        ) -> &mut Self {
1203            self.element.set_aria_flow_to_elements(Some(value.into()));
1204            self
1205        }
1206        /// Set the value of the `aria-grabbed` attribute
1207        pub fn aria_grabbed(&mut self, value: bool) -> &mut Self {
1208            self.element.set_aria_grabbed(value);
1209            self
1210        }
1211        /// Set the value of the `aria-haspopup` attribute
1212        pub fn aria_has_popup(
1213            &mut self,
1214            value: impl Into<std::borrow::Cow<'static, str>>,
1215        ) -> &mut Self {
1216            self.element.set_aria_has_popup(Some(value.into()));
1217            self
1218        }
1219        /// Set the value of the `aria-hidden` attribute
1220        pub fn aria_hidden(&mut self, value: bool) -> &mut Self {
1221            self.element.set_aria_hidden(value);
1222            self
1223        }
1224        /// Set the value of the `aria-invalid` attribute
1225        pub fn aria_invalid(
1226            &mut self,
1227            value: impl Into<std::borrow::Cow<'static, str>>,
1228        ) -> &mut Self {
1229            self.element.set_aria_invalid(Some(value.into()));
1230            self
1231        }
1232        /// Set the value of the `aria-keyshortcuts` attribute
1233        pub fn aria_key_shortcuts(
1234            &mut self,
1235            value: impl Into<std::borrow::Cow<'static, str>>,
1236        ) -> &mut Self {
1237            self.element.set_aria_key_shortcuts(Some(value.into()));
1238            self
1239        }
1240        /// Set the value of the `aria-label` attribute
1241        pub fn aria_label(
1242            &mut self,
1243            value: impl Into<std::borrow::Cow<'static, str>>,
1244        ) -> &mut Self {
1245            self.element.set_aria_label(Some(value.into()));
1246            self
1247        }
1248        /// Set the value of the `aria-labelledby` attribute
1249        pub fn aria_labelled_by_elements(
1250            &mut self,
1251            value: impl Into<std::borrow::Cow<'static, str>>,
1252        ) -> &mut Self {
1253            self.element.set_aria_labelled_by_elements(Some(value.into()));
1254            self
1255        }
1256        /// Set the value of the `aria-level` attribute
1257        pub fn aria_level(&mut self, value: i64) -> &mut Self {
1258            self.element.set_aria_level(Some(value));
1259            self
1260        }
1261        /// Set the value of the `aria-live` attribute
1262        pub fn aria_live(
1263            &mut self,
1264            value: impl Into<std::borrow::Cow<'static, str>>,
1265        ) -> &mut Self {
1266            self.element.set_aria_live(Some(value.into()));
1267            self
1268        }
1269        /// Set the value of the `aria-modal` attribute
1270        pub fn aria_modal(&mut self, value: bool) -> &mut Self {
1271            self.element.set_aria_modal(value);
1272            self
1273        }
1274        /// Set the value of the `aria-multiline` attribute
1275        pub fn aria_multi_line(&mut self, value: bool) -> &mut Self {
1276            self.element.set_aria_multi_line(value);
1277            self
1278        }
1279        /// Set the value of the `aria-multiselectable` attribute
1280        pub fn aria_multi_selectable(&mut self, value: bool) -> &mut Self {
1281            self.element.set_aria_multi_selectable(value);
1282            self
1283        }
1284        /// Set the value of the `aria-orientation` attribute
1285        pub fn aria_orientation(
1286            &mut self,
1287            value: impl Into<std::borrow::Cow<'static, str>>,
1288        ) -> &mut Self {
1289            self.element.set_aria_orientation(Some(value.into()));
1290            self
1291        }
1292        /// Set the value of the `aria-owns` attribute
1293        pub fn aria_owns_elements(
1294            &mut self,
1295            value: impl Into<std::borrow::Cow<'static, str>>,
1296        ) -> &mut Self {
1297            self.element.set_aria_owns_elements(Some(value.into()));
1298            self
1299        }
1300        /// Set the value of the `aria-placeholder` attribute
1301        pub fn aria_placeholder(
1302            &mut self,
1303            value: impl Into<std::borrow::Cow<'static, str>>,
1304        ) -> &mut Self {
1305            self.element.set_aria_placeholder(Some(value.into()));
1306            self
1307        }
1308        /// Set the value of the `aria-posinset` attribute
1309        pub fn aria_pos_in_set(&mut self, value: i64) -> &mut Self {
1310            self.element.set_aria_pos_in_set(Some(value));
1311            self
1312        }
1313        /// Set the value of the `aria-pressed` attribute
1314        pub fn aria_pressed(
1315            &mut self,
1316            value: impl Into<std::borrow::Cow<'static, str>>,
1317        ) -> &mut Self {
1318            self.element.set_aria_pressed(Some(value.into()));
1319            self
1320        }
1321        /// Set the value of the `aria-readonly` attribute
1322        pub fn aria_read_only(&mut self, value: bool) -> &mut Self {
1323            self.element.set_aria_read_only(value);
1324            self
1325        }
1326        /// Set the value of the `aria-relevant` attribute
1327        pub fn aria_relevant(
1328            &mut self,
1329            value: impl Into<std::borrow::Cow<'static, str>>,
1330        ) -> &mut Self {
1331            self.element.set_aria_relevant(Some(value.into()));
1332            self
1333        }
1334        /// Set the value of the `aria-required` attribute
1335        pub fn aria_required(&mut self, value: bool) -> &mut Self {
1336            self.element.set_aria_required(value);
1337            self
1338        }
1339        /// Set the value of the `aria-roledescription` attribute
1340        pub fn aria_role_description(
1341            &mut self,
1342            value: impl Into<std::borrow::Cow<'static, str>>,
1343        ) -> &mut Self {
1344            self.element.set_aria_role_description(Some(value.into()));
1345            self
1346        }
1347        /// Set the value of the `aria-rowcount` attribute
1348        pub fn aria_row_count(&mut self, value: i64) -> &mut Self {
1349            self.element.set_aria_row_count(Some(value));
1350            self
1351        }
1352        /// Set the value of the `aria-rowindex` attribute
1353        pub fn aria_row_index(&mut self, value: i64) -> &mut Self {
1354            self.element.set_aria_row_index(Some(value));
1355            self
1356        }
1357        /// Set the value of the `aria-rowindextext` attribute
1358        pub fn aria_row_index_text(
1359            &mut self,
1360            value: impl Into<std::borrow::Cow<'static, str>>,
1361        ) -> &mut Self {
1362            self.element.set_aria_row_index_text(Some(value.into()));
1363            self
1364        }
1365        /// Set the value of the `aria-rowspan` attribute
1366        pub fn aria_row_span(&mut self, value: i64) -> &mut Self {
1367            self.element.set_aria_row_span(Some(value));
1368            self
1369        }
1370        /// Set the value of the `aria-selected` attribute
1371        pub fn aria_selected(&mut self, value: bool) -> &mut Self {
1372            self.element.set_aria_selected(value);
1373            self
1374        }
1375        /// Set the value of the `aria-setsize` attribute
1376        pub fn aria_set_size(&mut self, value: i64) -> &mut Self {
1377            self.element.set_aria_set_size(Some(value));
1378            self
1379        }
1380        /// Set the value of the `aria-sort` attribute
1381        pub fn aria_sort(
1382            &mut self,
1383            value: impl Into<std::borrow::Cow<'static, str>>,
1384        ) -> &mut Self {
1385            self.element.set_aria_sort(Some(value.into()));
1386            self
1387        }
1388        /// Set the value of the `aria-valuemax` attribute
1389        pub fn aria_value_max(&mut self, value: f64) -> &mut Self {
1390            self.element.set_aria_value_max(Some(value));
1391            self
1392        }
1393        /// Set the value of the `aria-valuemin` attribute
1394        pub fn aria_value_min(&mut self, value: f64) -> &mut Self {
1395            self.element.set_aria_value_min(Some(value));
1396            self
1397        }
1398        /// Set the value of the `aria-valuenow` attribute
1399        pub fn aria_value_now(&mut self, value: f64) -> &mut Self {
1400            self.element.set_aria_value_now(Some(value));
1401            self
1402        }
1403        /// Set the value of the `aria-valuetext` attribute
1404        pub fn aria_value_text(
1405            &mut self,
1406            value: impl Into<std::borrow::Cow<'static, str>>,
1407        ) -> &mut Self {
1408            self.element.set_aria_value_text(Some(value.into()));
1409            self
1410        }
1411        /// Set the value of the `accesskey` attribute
1412        pub fn access_key(
1413            &mut self,
1414            value: impl Into<std::borrow::Cow<'static, str>>,
1415        ) -> &mut Self {
1416            self.element.set_access_key(Some(value.into()));
1417            self
1418        }
1419        /// Set the value of the `autocapitalize` attribute
1420        pub fn auto_capitalize(
1421            &mut self,
1422            value: impl Into<std::borrow::Cow<'static, str>>,
1423        ) -> &mut Self {
1424            self.element.set_auto_capitalize(Some(value.into()));
1425            self
1426        }
1427        /// Set the value of the `autofocus` attribute
1428        pub fn autofocus(&mut self, value: bool) -> &mut Self {
1429            self.element.set_autofocus(value);
1430            self
1431        }
1432        /// Set the value of the `class` attribute
1433        pub fn class(
1434            &mut self,
1435            value: impl Into<std::borrow::Cow<'static, str>>,
1436        ) -> &mut Self {
1437            self.element.set_class(Some(value.into()));
1438            self
1439        }
1440        /// Set the value of the `contenteditable` attribute
1441        pub fn content_editable(
1442            &mut self,
1443            value: impl Into<std::borrow::Cow<'static, str>>,
1444        ) -> &mut Self {
1445            self.element.set_content_editable(Some(value.into()));
1446            self
1447        }
1448        /// Set the value of the `dir` attribute
1449        pub fn direction(
1450            &mut self,
1451            value: impl Into<std::borrow::Cow<'static, str>>,
1452        ) -> &mut Self {
1453            self.element.set_direction(Some(value.into()));
1454            self
1455        }
1456        /// Set the value of the `draggable` attribute
1457        pub fn draggable(&mut self, value: bool) -> &mut Self {
1458            self.element.set_draggable(value);
1459            self
1460        }
1461        /// Set the value of the `enterkeyhint` attribute
1462        pub fn enter_key_hint(
1463            &mut self,
1464            value: impl Into<std::borrow::Cow<'static, str>>,
1465        ) -> &mut Self {
1466            self.element.set_enter_key_hint(Some(value.into()));
1467            self
1468        }
1469        /// Set the value of the `exportparts` attribute
1470        pub fn export_parts(
1471            &mut self,
1472            value: impl Into<std::borrow::Cow<'static, str>>,
1473        ) -> &mut Self {
1474            self.element.set_export_parts(Some(value.into()));
1475            self
1476        }
1477        /// Set the value of the `hidden` attribute
1478        pub fn hidden(
1479            &mut self,
1480            value: impl Into<std::borrow::Cow<'static, str>>,
1481        ) -> &mut Self {
1482            self.element.set_hidden(Some(value.into()));
1483            self
1484        }
1485        /// Set the value of the `id` attribute
1486        pub fn id(
1487            &mut self,
1488            value: impl Into<std::borrow::Cow<'static, str>>,
1489        ) -> &mut Self {
1490            self.element.set_id(Some(value.into()));
1491            self
1492        }
1493        /// Set the value of the `inert` attribute
1494        pub fn inert(&mut self, value: bool) -> &mut Self {
1495            self.element.set_inert(value);
1496            self
1497        }
1498        /// Set the value of the `inputmode` attribute
1499        pub fn input_mode(
1500            &mut self,
1501            value: impl Into<std::borrow::Cow<'static, str>>,
1502        ) -> &mut Self {
1503            self.element.set_input_mode(Some(value.into()));
1504            self
1505        }
1506        /// Set the value of the `is` attribute
1507        pub fn is_(
1508            &mut self,
1509            value: impl Into<std::borrow::Cow<'static, str>>,
1510        ) -> &mut Self {
1511            self.element.set_is_(Some(value.into()));
1512            self
1513        }
1514        /// Set the value of the `itemid` attribute
1515        pub fn item_id(
1516            &mut self,
1517            value: impl Into<std::borrow::Cow<'static, str>>,
1518        ) -> &mut Self {
1519            self.element.set_item_id(Some(value.into()));
1520            self
1521        }
1522        /// Set the value of the `itemprop` attribute
1523        pub fn item_prop(
1524            &mut self,
1525            value: impl Into<std::borrow::Cow<'static, str>>,
1526        ) -> &mut Self {
1527            self.element.set_item_prop(Some(value.into()));
1528            self
1529        }
1530        /// Set the value of the `itemref` attribute
1531        pub fn item_ref(
1532            &mut self,
1533            value: impl Into<std::borrow::Cow<'static, str>>,
1534        ) -> &mut Self {
1535            self.element.set_item_ref(Some(value.into()));
1536            self
1537        }
1538        /// Set the value of the `itemscope` attribute
1539        pub fn item_scope(
1540            &mut self,
1541            value: impl Into<std::borrow::Cow<'static, str>>,
1542        ) -> &mut Self {
1543            self.element.set_item_scope(Some(value.into()));
1544            self
1545        }
1546        /// Set the value of the `itemtype` attribute
1547        pub fn item_type(
1548            &mut self,
1549            value: impl Into<std::borrow::Cow<'static, str>>,
1550        ) -> &mut Self {
1551            self.element.set_item_type(Some(value.into()));
1552            self
1553        }
1554        /// Set the value of the `lang` attribute
1555        pub fn lang(
1556            &mut self,
1557            value: impl Into<std::borrow::Cow<'static, str>>,
1558        ) -> &mut Self {
1559            self.element.set_lang(Some(value.into()));
1560            self
1561        }
1562        /// Set the value of the `nonce` attribute
1563        pub fn nonce(
1564            &mut self,
1565            value: impl Into<std::borrow::Cow<'static, str>>,
1566        ) -> &mut Self {
1567            self.element.set_nonce(Some(value.into()));
1568            self
1569        }
1570        /// Set the value of the `part` attribute
1571        pub fn part(
1572            &mut self,
1573            value: impl Into<std::borrow::Cow<'static, str>>,
1574        ) -> &mut Self {
1575            self.element.set_part(Some(value.into()));
1576            self
1577        }
1578        /// Set the value of the `slot` attribute
1579        pub fn slot(
1580            &mut self,
1581            value: impl Into<std::borrow::Cow<'static, str>>,
1582        ) -> &mut Self {
1583            self.element.set_slot(Some(value.into()));
1584            self
1585        }
1586        /// Set the value of the `spellcheck` attribute
1587        pub fn spellcheck(
1588            &mut self,
1589            value: impl Into<std::borrow::Cow<'static, str>>,
1590        ) -> &mut Self {
1591            self.element.set_spellcheck(Some(value.into()));
1592            self
1593        }
1594        /// Set the value of the `style` attribute
1595        pub fn style(
1596            &mut self,
1597            value: impl Into<std::borrow::Cow<'static, str>>,
1598        ) -> &mut Self {
1599            self.element.set_style(Some(value.into()));
1600            self
1601        }
1602        /// Set the value of the `tabindex` attribute
1603        pub fn tab_index(&mut self, value: i64) -> &mut Self {
1604            self.element.set_tab_index(Some(value));
1605            self
1606        }
1607        /// Set the value of the `title` attribute
1608        pub fn title(
1609            &mut self,
1610            value: impl Into<std::borrow::Cow<'static, str>>,
1611        ) -> &mut Self {
1612            self.element.set_title(Some(value.into()));
1613            self
1614        }
1615        /// Set the value of the `translate` attribute
1616        pub fn translate(&mut self, value: bool) -> &mut Self {
1617            self.element.set_translate(value);
1618            self
1619        }
1620        /// Push a new child element to the list of children.
1621        pub fn push<T>(&mut self, child_el: T) -> &mut Self
1622        where
1623            T: Into<crate::generated::all::children::TableRowChild>,
1624        {
1625            let child_el = child_el.into();
1626            self.element.children_mut().push(child_el);
1627            self
1628        }
1629        /// Extend the list of children with an iterator of child elements.
1630        pub fn extend<I, T>(&mut self, iter: I) -> &mut Self
1631        where
1632            I: IntoIterator<Item = T>,
1633            T: Into<crate::generated::all::children::TableRowChild>,
1634        {
1635            let iter = iter.into_iter().map(|child_el| child_el.into());
1636            self.element.children_mut().extend(iter);
1637            self
1638        }
1639    }
1640}
html/generated/tr.rs

html/generated/
tr.rs
