html/generated/
table.rs

1pub mod element {
2    /// The HTML `<table>` element
3    ///
4    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/table)
5    #[doc(alias = "table")]
6    #[non_exhaustive]
7    #[derive(PartialEq, Clone, Default)]
8    pub struct Table {
9        sys: html_sys::tables::Table,
10        children: Vec<super::child::TableChild>,
11    }
12    impl Table {
13        /// Create a new builder
14        pub fn builder() -> super::builder::TableBuilder {
15            super::builder::TableBuilder::new(Default::default())
16        }
17    }
18    impl Table {
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 Table {
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 Table {
846        /// Access the element's children
847        pub fn children(&self) -> &[super::child::TableChild] {
848            self.children.as_ref()
849        }
850        /// Mutably access the element's children
851        pub fn children_mut(&mut self) -> &mut Vec<super::child::TableChild> {
852            &mut self.children
853        }
854    }
855    impl crate::Render for Table {
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 Table {
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 Table {
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 Table {}
892    impl crate::FlowContent for Table {}
893    impl crate::PalpableContent for Table {}
894    impl std::convert::Into<html_sys::tables::Table> for Table {
895        fn into(self) -> html_sys::tables::Table {
896            self.sys
897        }
898    }
899    impl From<html_sys::tables::Table> for Table {
900        fn from(sys: html_sys::tables::Table) -> Self {
901            Self { sys, children: vec![] }
902        }
903    }
904}
905pub mod child {
906    /// The permitted child items for the `Table` element
907    #[derive(PartialEq, Clone)]
908    pub enum TableChild {
909        /// The Caption element
910        Caption(crate::generated::all::Caption),
911        /// The Script element
912        Script(crate::generated::all::Script),
913        /// The TableBody element
914        TableBody(crate::generated::all::TableBody),
915        /// The TableColumnGroup element
916        TableColumnGroup(crate::generated::all::TableColumnGroup),
917        /// The TableFoot element
918        TableFoot(crate::generated::all::TableFoot),
919        /// The TableHead element
920        TableHead(crate::generated::all::TableHead),
921        /// The TableRow element
922        TableRow(crate::generated::all::TableRow),
923        /// The Template element
924        Template(crate::generated::all::Template),
925    }
926    impl std::convert::From<crate::generated::all::Caption> for TableChild {
927        fn from(value: crate::generated::all::Caption) -> Self {
928            Self::Caption(value)
929        }
930    }
931    impl std::convert::From<crate::generated::all::Script> for TableChild {
932        fn from(value: crate::generated::all::Script) -> Self {
933            Self::Script(value)
934        }
935    }
936    impl std::convert::From<crate::generated::all::TableBody> for TableChild {
937        fn from(value: crate::generated::all::TableBody) -> Self {
938            Self::TableBody(value)
939        }
940    }
941    impl std::convert::From<crate::generated::all::TableColumnGroup> for TableChild {
942        fn from(value: crate::generated::all::TableColumnGroup) -> Self {
943            Self::TableColumnGroup(value)
944        }
945    }
946    impl std::convert::From<crate::generated::all::TableFoot> for TableChild {
947        fn from(value: crate::generated::all::TableFoot) -> Self {
948            Self::TableFoot(value)
949        }
950    }
951    impl std::convert::From<crate::generated::all::TableHead> for TableChild {
952        fn from(value: crate::generated::all::TableHead) -> Self {
953            Self::TableHead(value)
954        }
955    }
956    impl std::convert::From<crate::generated::all::TableRow> for TableChild {
957        fn from(value: crate::generated::all::TableRow) -> Self {
958            Self::TableRow(value)
959        }
960    }
961    impl std::convert::From<crate::generated::all::Template> for TableChild {
962        fn from(value: crate::generated::all::Template) -> Self {
963            Self::Template(value)
964        }
965    }
966    impl crate::Render for TableChild {
967        fn render(
968            &self,
969            f: &mut std::fmt::Formatter<'_>,
970            depth: usize,
971        ) -> std::fmt::Result {
972            match self {
973                Self::Caption(el) => crate::Render::render(el, f, depth + 1),
974                Self::Script(el) => crate::Render::render(el, f, depth + 1),
975                Self::TableBody(el) => crate::Render::render(el, f, depth + 1),
976                Self::TableColumnGroup(el) => crate::Render::render(el, f, depth + 1),
977                Self::TableFoot(el) => crate::Render::render(el, f, depth + 1),
978                Self::TableHead(el) => crate::Render::render(el, f, depth + 1),
979                Self::TableRow(el) => crate::Render::render(el, f, depth + 1),
980                Self::Template(el) => crate::Render::render(el, f, depth + 1),
981            }
982        }
983    }
984    impl std::fmt::Debug for TableChild {
985        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
986            crate::Render::render(self, f, 0)?;
987            Ok(())
988        }
989    }
990    impl std::fmt::Display for TableChild {
991        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
992            match self {
993                Self::Caption(el) => write!(f, "{el}"),
994                Self::Script(el) => write!(f, "{el}"),
995                Self::TableBody(el) => write!(f, "{el}"),
996                Self::TableColumnGroup(el) => write!(f, "{el}"),
997                Self::TableFoot(el) => write!(f, "{el}"),
998                Self::TableHead(el) => write!(f, "{el}"),
999                Self::TableRow(el) => write!(f, "{el}"),
1000                Self::Template(el) => write!(f, "{el}"),
1001            }
1002        }
1003    }
1004}
1005pub mod builder {
1006    /// A builder struct for Table
1007    pub struct TableBuilder {
1008        element: super::element::Table,
1009    }
1010    impl TableBuilder {
1011        pub(crate) fn new(element: super::element::Table) -> Self {
1012            Self { element }
1013        }
1014        /// Finish building the element
1015        pub fn build(&mut self) -> super::element::Table {
1016            self.element.clone()
1017        }
1018        /// Insert a `data-*` property
1019        pub fn data(
1020            &mut self,
1021            data_key: impl Into<std::borrow::Cow<'static, str>>,
1022            value: impl Into<std::borrow::Cow<'static, str>>,
1023        ) -> &mut TableBuilder {
1024            self.element.data_map_mut().insert(data_key.into(), value.into());
1025            self
1026        }
1027        /// Append a new `Caption` element
1028        pub fn caption<F>(&mut self, f: F) -> &mut Self
1029        where
1030            F: for<'a> FnOnce(
1031                &'a mut crate::generated::all::builders::CaptionBuilder,
1032            ) -> &'a mut crate::generated::all::builders::CaptionBuilder,
1033        {
1034            let ty: crate::generated::all::Caption = Default::default();
1035            let mut ty_builder = crate::generated::all::builders::CaptionBuilder::new(
1036                ty,
1037            );
1038            (f)(&mut ty_builder);
1039            let ty = ty_builder.build();
1040            self.element.children_mut().push(ty.into());
1041            self
1042        }
1043        /// Append a new `Script` element
1044        pub fn script<F>(&mut self, f: F) -> &mut Self
1045        where
1046            F: for<'a> FnOnce(
1047                &'a mut crate::generated::all::builders::ScriptBuilder,
1048            ) -> &'a mut crate::generated::all::builders::ScriptBuilder,
1049        {
1050            let ty: crate::generated::all::Script = Default::default();
1051            let mut ty_builder = crate::generated::all::builders::ScriptBuilder::new(ty);
1052            (f)(&mut ty_builder);
1053            let ty = ty_builder.build();
1054            self.element.children_mut().push(ty.into());
1055            self
1056        }
1057        /// Append a new `TableBody` element
1058        pub fn table_body<F>(&mut self, f: F) -> &mut Self
1059        where
1060            F: for<'a> FnOnce(
1061                &'a mut crate::generated::all::builders::TableBodyBuilder,
1062            ) -> &'a mut crate::generated::all::builders::TableBodyBuilder,
1063        {
1064            let ty: crate::generated::all::TableBody = Default::default();
1065            let mut ty_builder = crate::generated::all::builders::TableBodyBuilder::new(
1066                ty,
1067            );
1068            (f)(&mut ty_builder);
1069            let ty = ty_builder.build();
1070            self.element.children_mut().push(ty.into());
1071            self
1072        }
1073        /// Append a new `TableColumnGroup` element
1074        pub fn table_column_group<F>(&mut self, f: F) -> &mut Self
1075        where
1076            F: for<'a> FnOnce(
1077                &'a mut crate::generated::all::builders::TableColumnGroupBuilder,
1078            ) -> &'a mut crate::generated::all::builders::TableColumnGroupBuilder,
1079        {
1080            let ty: crate::generated::all::TableColumnGroup = Default::default();
1081            let mut ty_builder = crate::generated::all::builders::TableColumnGroupBuilder::new(
1082                ty,
1083            );
1084            (f)(&mut ty_builder);
1085            let ty = ty_builder.build();
1086            self.element.children_mut().push(ty.into());
1087            self
1088        }
1089        /// Append a new `TableFoot` element
1090        pub fn table_foot<F>(&mut self, f: F) -> &mut Self
1091        where
1092            F: for<'a> FnOnce(
1093                &'a mut crate::generated::all::builders::TableFootBuilder,
1094            ) -> &'a mut crate::generated::all::builders::TableFootBuilder,
1095        {
1096            let ty: crate::generated::all::TableFoot = Default::default();
1097            let mut ty_builder = crate::generated::all::builders::TableFootBuilder::new(
1098                ty,
1099            );
1100            (f)(&mut ty_builder);
1101            let ty = ty_builder.build();
1102            self.element.children_mut().push(ty.into());
1103            self
1104        }
1105        /// Append a new `TableHead` element
1106        pub fn table_head<F>(&mut self, f: F) -> &mut Self
1107        where
1108            F: for<'a> FnOnce(
1109                &'a mut crate::generated::all::builders::TableHeadBuilder,
1110            ) -> &'a mut crate::generated::all::builders::TableHeadBuilder,
1111        {
1112            let ty: crate::generated::all::TableHead = Default::default();
1113            let mut ty_builder = crate::generated::all::builders::TableHeadBuilder::new(
1114                ty,
1115            );
1116            (f)(&mut ty_builder);
1117            let ty = ty_builder.build();
1118            self.element.children_mut().push(ty.into());
1119            self
1120        }
1121        /// Append a new `TableRow` element
1122        pub fn table_row<F>(&mut self, f: F) -> &mut Self
1123        where
1124            F: for<'a> FnOnce(
1125                &'a mut crate::generated::all::builders::TableRowBuilder,
1126            ) -> &'a mut crate::generated::all::builders::TableRowBuilder,
1127        {
1128            let ty: crate::generated::all::TableRow = Default::default();
1129            let mut ty_builder = crate::generated::all::builders::TableRowBuilder::new(
1130                ty,
1131            );
1132            (f)(&mut ty_builder);
1133            let ty = ty_builder.build();
1134            self.element.children_mut().push(ty.into());
1135            self
1136        }
1137        /// Append a new `Template` element
1138        pub fn template<F>(&mut self, f: F) -> &mut Self
1139        where
1140            F: for<'a> FnOnce(
1141                &'a mut crate::generated::all::builders::TemplateBuilder,
1142            ) -> &'a mut crate::generated::all::builders::TemplateBuilder,
1143        {
1144            let ty: crate::generated::all::Template = Default::default();
1145            let mut ty_builder = crate::generated::all::builders::TemplateBuilder::new(
1146                ty,
1147            );
1148            (f)(&mut ty_builder);
1149            let ty = ty_builder.build();
1150            self.element.children_mut().push(ty.into());
1151            self
1152        }
1153        /// Set the value of the `role` attribute
1154        pub fn role(
1155            &mut self,
1156            value: impl Into<std::borrow::Cow<'static, str>>,
1157        ) -> &mut Self {
1158            self.element.set_role(Some(value.into()));
1159            self
1160        }
1161        /// Set the value of the `aria-activedescendant` attribute
1162        pub fn aria_active_descendant_element(
1163            &mut self,
1164            value: impl Into<std::borrow::Cow<'static, str>>,
1165        ) -> &mut Self {
1166            self.element.set_aria_active_descendant_element(Some(value.into()));
1167            self
1168        }
1169        /// Set the value of the `aria-atomic` attribute
1170        pub fn aria_atomic(&mut self, value: bool) -> &mut Self {
1171            self.element.set_aria_atomic(value);
1172            self
1173        }
1174        /// Set the value of the `aria-autocomplete` attribute
1175        pub fn aria_auto_complete(
1176            &mut self,
1177            value: impl Into<std::borrow::Cow<'static, str>>,
1178        ) -> &mut Self {
1179            self.element.set_aria_auto_complete(Some(value.into()));
1180            self
1181        }
1182        /// Set the value of the `aria-braillelabel` attribute
1183        pub fn aria_braille_label(
1184            &mut self,
1185            value: impl Into<std::borrow::Cow<'static, str>>,
1186        ) -> &mut Self {
1187            self.element.set_aria_braille_label(Some(value.into()));
1188            self
1189        }
1190        /// Set the value of the `aria-brailleroledescription` attribute
1191        pub fn aria_braille_role_description(
1192            &mut self,
1193            value: impl Into<std::borrow::Cow<'static, str>>,
1194        ) -> &mut Self {
1195            self.element.set_aria_braille_role_description(Some(value.into()));
1196            self
1197        }
1198        /// Set the value of the `aria-busy` attribute
1199        pub fn aria_busy(&mut self, value: bool) -> &mut Self {
1200            self.element.set_aria_busy(value);
1201            self
1202        }
1203        /// Set the value of the `aria-checked` attribute
1204        pub fn aria_checked(
1205            &mut self,
1206            value: impl Into<std::borrow::Cow<'static, str>>,
1207        ) -> &mut Self {
1208            self.element.set_aria_checked(Some(value.into()));
1209            self
1210        }
1211        /// Set the value of the `aria-colcount` attribute
1212        pub fn aria_col_count(&mut self, value: i64) -> &mut Self {
1213            self.element.set_aria_col_count(Some(value));
1214            self
1215        }
1216        /// Set the value of the `aria-colindex` attribute
1217        pub fn aria_col_index(&mut self, value: i64) -> &mut Self {
1218            self.element.set_aria_col_index(Some(value));
1219            self
1220        }
1221        /// Set the value of the `aria-colindextext` attribute
1222        pub fn aria_col_index_text(
1223            &mut self,
1224            value: impl Into<std::borrow::Cow<'static, str>>,
1225        ) -> &mut Self {
1226            self.element.set_aria_col_index_text(Some(value.into()));
1227            self
1228        }
1229        /// Set the value of the `aria-colspan` attribute
1230        pub fn aria_col_span(&mut self, value: i64) -> &mut Self {
1231            self.element.set_aria_col_span(Some(value));
1232            self
1233        }
1234        /// Set the value of the `aria-controls` attribute
1235        pub fn aria_controls_elements(
1236            &mut self,
1237            value: impl Into<std::borrow::Cow<'static, str>>,
1238        ) -> &mut Self {
1239            self.element.set_aria_controls_elements(Some(value.into()));
1240            self
1241        }
1242        /// Set the value of the `aria-current` attribute
1243        pub fn aria_current(
1244            &mut self,
1245            value: impl Into<std::borrow::Cow<'static, str>>,
1246        ) -> &mut Self {
1247            self.element.set_aria_current(Some(value.into()));
1248            self
1249        }
1250        /// Set the value of the `aria-describedby` attribute
1251        pub fn aria_described_by_elements(
1252            &mut self,
1253            value: impl Into<std::borrow::Cow<'static, str>>,
1254        ) -> &mut Self {
1255            self.element.set_aria_described_by_elements(Some(value.into()));
1256            self
1257        }
1258        /// Set the value of the `aria-description` attribute
1259        pub fn aria_description(
1260            &mut self,
1261            value: impl Into<std::borrow::Cow<'static, str>>,
1262        ) -> &mut Self {
1263            self.element.set_aria_description(Some(value.into()));
1264            self
1265        }
1266        /// Set the value of the `aria-details` attribute
1267        pub fn aria_details_elements(
1268            &mut self,
1269            value: impl Into<std::borrow::Cow<'static, str>>,
1270        ) -> &mut Self {
1271            self.element.set_aria_details_elements(Some(value.into()));
1272            self
1273        }
1274        /// Set the value of the `aria-disabled` attribute
1275        pub fn aria_disabled(&mut self, value: bool) -> &mut Self {
1276            self.element.set_aria_disabled(value);
1277            self
1278        }
1279        /// Set the value of the `aria-dropeffect` attribute
1280        pub fn aria_drop_effect(
1281            &mut self,
1282            value: impl Into<std::borrow::Cow<'static, str>>,
1283        ) -> &mut Self {
1284            self.element.set_aria_drop_effect(Some(value.into()));
1285            self
1286        }
1287        /// Set the value of the `aria-errormessage` attribute
1288        pub fn aria_error_message_elements(
1289            &mut self,
1290            value: impl Into<std::borrow::Cow<'static, str>>,
1291        ) -> &mut Self {
1292            self.element.set_aria_error_message_elements(Some(value.into()));
1293            self
1294        }
1295        /// Set the value of the `aria-expanded` attribute
1296        pub fn aria_expanded(&mut self, value: bool) -> &mut Self {
1297            self.element.set_aria_expanded(value);
1298            self
1299        }
1300        /// Set the value of the `aria-flowto` attribute
1301        pub fn aria_flow_to_elements(
1302            &mut self,
1303            value: impl Into<std::borrow::Cow<'static, str>>,
1304        ) -> &mut Self {
1305            self.element.set_aria_flow_to_elements(Some(value.into()));
1306            self
1307        }
1308        /// Set the value of the `aria-grabbed` attribute
1309        pub fn aria_grabbed(&mut self, value: bool) -> &mut Self {
1310            self.element.set_aria_grabbed(value);
1311            self
1312        }
1313        /// Set the value of the `aria-haspopup` attribute
1314        pub fn aria_has_popup(
1315            &mut self,
1316            value: impl Into<std::borrow::Cow<'static, str>>,
1317        ) -> &mut Self {
1318            self.element.set_aria_has_popup(Some(value.into()));
1319            self
1320        }
1321        /// Set the value of the `aria-hidden` attribute
1322        pub fn aria_hidden(&mut self, value: bool) -> &mut Self {
1323            self.element.set_aria_hidden(value);
1324            self
1325        }
1326        /// Set the value of the `aria-invalid` attribute
1327        pub fn aria_invalid(
1328            &mut self,
1329            value: impl Into<std::borrow::Cow<'static, str>>,
1330        ) -> &mut Self {
1331            self.element.set_aria_invalid(Some(value.into()));
1332            self
1333        }
1334        /// Set the value of the `aria-keyshortcuts` attribute
1335        pub fn aria_key_shortcuts(
1336            &mut self,
1337            value: impl Into<std::borrow::Cow<'static, str>>,
1338        ) -> &mut Self {
1339            self.element.set_aria_key_shortcuts(Some(value.into()));
1340            self
1341        }
1342        /// Set the value of the `aria-label` attribute
1343        pub fn aria_label(
1344            &mut self,
1345            value: impl Into<std::borrow::Cow<'static, str>>,
1346        ) -> &mut Self {
1347            self.element.set_aria_label(Some(value.into()));
1348            self
1349        }
1350        /// Set the value of the `aria-labelledby` attribute
1351        pub fn aria_labelled_by_elements(
1352            &mut self,
1353            value: impl Into<std::borrow::Cow<'static, str>>,
1354        ) -> &mut Self {
1355            self.element.set_aria_labelled_by_elements(Some(value.into()));
1356            self
1357        }
1358        /// Set the value of the `aria-level` attribute
1359        pub fn aria_level(&mut self, value: i64) -> &mut Self {
1360            self.element.set_aria_level(Some(value));
1361            self
1362        }
1363        /// Set the value of the `aria-live` attribute
1364        pub fn aria_live(
1365            &mut self,
1366            value: impl Into<std::borrow::Cow<'static, str>>,
1367        ) -> &mut Self {
1368            self.element.set_aria_live(Some(value.into()));
1369            self
1370        }
1371        /// Set the value of the `aria-modal` attribute
1372        pub fn aria_modal(&mut self, value: bool) -> &mut Self {
1373            self.element.set_aria_modal(value);
1374            self
1375        }
1376        /// Set the value of the `aria-multiline` attribute
1377        pub fn aria_multi_line(&mut self, value: bool) -> &mut Self {
1378            self.element.set_aria_multi_line(value);
1379            self
1380        }
1381        /// Set the value of the `aria-multiselectable` attribute
1382        pub fn aria_multi_selectable(&mut self, value: bool) -> &mut Self {
1383            self.element.set_aria_multi_selectable(value);
1384            self
1385        }
1386        /// Set the value of the `aria-orientation` attribute
1387        pub fn aria_orientation(
1388            &mut self,
1389            value: impl Into<std::borrow::Cow<'static, str>>,
1390        ) -> &mut Self {
1391            self.element.set_aria_orientation(Some(value.into()));
1392            self
1393        }
1394        /// Set the value of the `aria-owns` attribute
1395        pub fn aria_owns_elements(
1396            &mut self,
1397            value: impl Into<std::borrow::Cow<'static, str>>,
1398        ) -> &mut Self {
1399            self.element.set_aria_owns_elements(Some(value.into()));
1400            self
1401        }
1402        /// Set the value of the `aria-placeholder` attribute
1403        pub fn aria_placeholder(
1404            &mut self,
1405            value: impl Into<std::borrow::Cow<'static, str>>,
1406        ) -> &mut Self {
1407            self.element.set_aria_placeholder(Some(value.into()));
1408            self
1409        }
1410        /// Set the value of the `aria-posinset` attribute
1411        pub fn aria_pos_in_set(&mut self, value: i64) -> &mut Self {
1412            self.element.set_aria_pos_in_set(Some(value));
1413            self
1414        }
1415        /// Set the value of the `aria-pressed` attribute
1416        pub fn aria_pressed(
1417            &mut self,
1418            value: impl Into<std::borrow::Cow<'static, str>>,
1419        ) -> &mut Self {
1420            self.element.set_aria_pressed(Some(value.into()));
1421            self
1422        }
1423        /// Set the value of the `aria-readonly` attribute
1424        pub fn aria_read_only(&mut self, value: bool) -> &mut Self {
1425            self.element.set_aria_read_only(value);
1426            self
1427        }
1428        /// Set the value of the `aria-relevant` attribute
1429        pub fn aria_relevant(
1430            &mut self,
1431            value: impl Into<std::borrow::Cow<'static, str>>,
1432        ) -> &mut Self {
1433            self.element.set_aria_relevant(Some(value.into()));
1434            self
1435        }
1436        /// Set the value of the `aria-required` attribute
1437        pub fn aria_required(&mut self, value: bool) -> &mut Self {
1438            self.element.set_aria_required(value);
1439            self
1440        }
1441        /// Set the value of the `aria-roledescription` attribute
1442        pub fn aria_role_description(
1443            &mut self,
1444            value: impl Into<std::borrow::Cow<'static, str>>,
1445        ) -> &mut Self {
1446            self.element.set_aria_role_description(Some(value.into()));
1447            self
1448        }
1449        /// Set the value of the `aria-rowcount` attribute
1450        pub fn aria_row_count(&mut self, value: i64) -> &mut Self {
1451            self.element.set_aria_row_count(Some(value));
1452            self
1453        }
1454        /// Set the value of the `aria-rowindex` attribute
1455        pub fn aria_row_index(&mut self, value: i64) -> &mut Self {
1456            self.element.set_aria_row_index(Some(value));
1457            self
1458        }
1459        /// Set the value of the `aria-rowindextext` attribute
1460        pub fn aria_row_index_text(
1461            &mut self,
1462            value: impl Into<std::borrow::Cow<'static, str>>,
1463        ) -> &mut Self {
1464            self.element.set_aria_row_index_text(Some(value.into()));
1465            self
1466        }
1467        /// Set the value of the `aria-rowspan` attribute
1468        pub fn aria_row_span(&mut self, value: i64) -> &mut Self {
1469            self.element.set_aria_row_span(Some(value));
1470            self
1471        }
1472        /// Set the value of the `aria-selected` attribute
1473        pub fn aria_selected(&mut self, value: bool) -> &mut Self {
1474            self.element.set_aria_selected(value);
1475            self
1476        }
1477        /// Set the value of the `aria-setsize` attribute
1478        pub fn aria_set_size(&mut self, value: i64) -> &mut Self {
1479            self.element.set_aria_set_size(Some(value));
1480            self
1481        }
1482        /// Set the value of the `aria-sort` attribute
1483        pub fn aria_sort(
1484            &mut self,
1485            value: impl Into<std::borrow::Cow<'static, str>>,
1486        ) -> &mut Self {
1487            self.element.set_aria_sort(Some(value.into()));
1488            self
1489        }
1490        /// Set the value of the `aria-valuemax` attribute
1491        pub fn aria_value_max(&mut self, value: f64) -> &mut Self {
1492            self.element.set_aria_value_max(Some(value));
1493            self
1494        }
1495        /// Set the value of the `aria-valuemin` attribute
1496        pub fn aria_value_min(&mut self, value: f64) -> &mut Self {
1497            self.element.set_aria_value_min(Some(value));
1498            self
1499        }
1500        /// Set the value of the `aria-valuenow` attribute
1501        pub fn aria_value_now(&mut self, value: f64) -> &mut Self {
1502            self.element.set_aria_value_now(Some(value));
1503            self
1504        }
1505        /// Set the value of the `aria-valuetext` attribute
1506        pub fn aria_value_text(
1507            &mut self,
1508            value: impl Into<std::borrow::Cow<'static, str>>,
1509        ) -> &mut Self {
1510            self.element.set_aria_value_text(Some(value.into()));
1511            self
1512        }
1513        /// Set the value of the `accesskey` attribute
1514        pub fn access_key(
1515            &mut self,
1516            value: impl Into<std::borrow::Cow<'static, str>>,
1517        ) -> &mut Self {
1518            self.element.set_access_key(Some(value.into()));
1519            self
1520        }
1521        /// Set the value of the `autocapitalize` attribute
1522        pub fn auto_capitalize(
1523            &mut self,
1524            value: impl Into<std::borrow::Cow<'static, str>>,
1525        ) -> &mut Self {
1526            self.element.set_auto_capitalize(Some(value.into()));
1527            self
1528        }
1529        /// Set the value of the `autofocus` attribute
1530        pub fn autofocus(&mut self, value: bool) -> &mut Self {
1531            self.element.set_autofocus(value);
1532            self
1533        }
1534        /// Set the value of the `class` attribute
1535        pub fn class(
1536            &mut self,
1537            value: impl Into<std::borrow::Cow<'static, str>>,
1538        ) -> &mut Self {
1539            self.element.set_class(Some(value.into()));
1540            self
1541        }
1542        /// Set the value of the `contenteditable` attribute
1543        pub fn content_editable(
1544            &mut self,
1545            value: impl Into<std::borrow::Cow<'static, str>>,
1546        ) -> &mut Self {
1547            self.element.set_content_editable(Some(value.into()));
1548            self
1549        }
1550        /// Set the value of the `dir` attribute
1551        pub fn direction(
1552            &mut self,
1553            value: impl Into<std::borrow::Cow<'static, str>>,
1554        ) -> &mut Self {
1555            self.element.set_direction(Some(value.into()));
1556            self
1557        }
1558        /// Set the value of the `draggable` attribute
1559        pub fn draggable(&mut self, value: bool) -> &mut Self {
1560            self.element.set_draggable(value);
1561            self
1562        }
1563        /// Set the value of the `enterkeyhint` attribute
1564        pub fn enter_key_hint(
1565            &mut self,
1566            value: impl Into<std::borrow::Cow<'static, str>>,
1567        ) -> &mut Self {
1568            self.element.set_enter_key_hint(Some(value.into()));
1569            self
1570        }
1571        /// Set the value of the `exportparts` attribute
1572        pub fn export_parts(
1573            &mut self,
1574            value: impl Into<std::borrow::Cow<'static, str>>,
1575        ) -> &mut Self {
1576            self.element.set_export_parts(Some(value.into()));
1577            self
1578        }
1579        /// Set the value of the `hidden` attribute
1580        pub fn hidden(
1581            &mut self,
1582            value: impl Into<std::borrow::Cow<'static, str>>,
1583        ) -> &mut Self {
1584            self.element.set_hidden(Some(value.into()));
1585            self
1586        }
1587        /// Set the value of the `id` attribute
1588        pub fn id(
1589            &mut self,
1590            value: impl Into<std::borrow::Cow<'static, str>>,
1591        ) -> &mut Self {
1592            self.element.set_id(Some(value.into()));
1593            self
1594        }
1595        /// Set the value of the `inert` attribute
1596        pub fn inert(&mut self, value: bool) -> &mut Self {
1597            self.element.set_inert(value);
1598            self
1599        }
1600        /// Set the value of the `inputmode` attribute
1601        pub fn input_mode(
1602            &mut self,
1603            value: impl Into<std::borrow::Cow<'static, str>>,
1604        ) -> &mut Self {
1605            self.element.set_input_mode(Some(value.into()));
1606            self
1607        }
1608        /// Set the value of the `is` attribute
1609        pub fn is_(
1610            &mut self,
1611            value: impl Into<std::borrow::Cow<'static, str>>,
1612        ) -> &mut Self {
1613            self.element.set_is_(Some(value.into()));
1614            self
1615        }
1616        /// Set the value of the `itemid` attribute
1617        pub fn item_id(
1618            &mut self,
1619            value: impl Into<std::borrow::Cow<'static, str>>,
1620        ) -> &mut Self {
1621            self.element.set_item_id(Some(value.into()));
1622            self
1623        }
1624        /// Set the value of the `itemprop` attribute
1625        pub fn item_prop(
1626            &mut self,
1627            value: impl Into<std::borrow::Cow<'static, str>>,
1628        ) -> &mut Self {
1629            self.element.set_item_prop(Some(value.into()));
1630            self
1631        }
1632        /// Set the value of the `itemref` attribute
1633        pub fn item_ref(
1634            &mut self,
1635            value: impl Into<std::borrow::Cow<'static, str>>,
1636        ) -> &mut Self {
1637            self.element.set_item_ref(Some(value.into()));
1638            self
1639        }
1640        /// Set the value of the `itemscope` attribute
1641        pub fn item_scope(
1642            &mut self,
1643            value: impl Into<std::borrow::Cow<'static, str>>,
1644        ) -> &mut Self {
1645            self.element.set_item_scope(Some(value.into()));
1646            self
1647        }
1648        /// Set the value of the `itemtype` attribute
1649        pub fn item_type(
1650            &mut self,
1651            value: impl Into<std::borrow::Cow<'static, str>>,
1652        ) -> &mut Self {
1653            self.element.set_item_type(Some(value.into()));
1654            self
1655        }
1656        /// Set the value of the `lang` attribute
1657        pub fn lang(
1658            &mut self,
1659            value: impl Into<std::borrow::Cow<'static, str>>,
1660        ) -> &mut Self {
1661            self.element.set_lang(Some(value.into()));
1662            self
1663        }
1664        /// Set the value of the `nonce` attribute
1665        pub fn nonce(
1666            &mut self,
1667            value: impl Into<std::borrow::Cow<'static, str>>,
1668        ) -> &mut Self {
1669            self.element.set_nonce(Some(value.into()));
1670            self
1671        }
1672        /// Set the value of the `part` attribute
1673        pub fn part(
1674            &mut self,
1675            value: impl Into<std::borrow::Cow<'static, str>>,
1676        ) -> &mut Self {
1677            self.element.set_part(Some(value.into()));
1678            self
1679        }
1680        /// Set the value of the `slot` attribute
1681        pub fn slot(
1682            &mut self,
1683            value: impl Into<std::borrow::Cow<'static, str>>,
1684        ) -> &mut Self {
1685            self.element.set_slot(Some(value.into()));
1686            self
1687        }
1688        /// Set the value of the `spellcheck` attribute
1689        pub fn spellcheck(
1690            &mut self,
1691            value: impl Into<std::borrow::Cow<'static, str>>,
1692        ) -> &mut Self {
1693            self.element.set_spellcheck(Some(value.into()));
1694            self
1695        }
1696        /// Set the value of the `style` attribute
1697        pub fn style(
1698            &mut self,
1699            value: impl Into<std::borrow::Cow<'static, str>>,
1700        ) -> &mut Self {
1701            self.element.set_style(Some(value.into()));
1702            self
1703        }
1704        /// Set the value of the `tabindex` attribute
1705        pub fn tab_index(&mut self, value: i64) -> &mut Self {
1706            self.element.set_tab_index(Some(value));
1707            self
1708        }
1709        /// Set the value of the `title` attribute
1710        pub fn title(
1711            &mut self,
1712            value: impl Into<std::borrow::Cow<'static, str>>,
1713        ) -> &mut Self {
1714            self.element.set_title(Some(value.into()));
1715            self
1716        }
1717        /// Set the value of the `translate` attribute
1718        pub fn translate(&mut self, value: bool) -> &mut Self {
1719            self.element.set_translate(value);
1720            self
1721        }
1722        /// Push a new child element to the list of children.
1723        pub fn push<T>(&mut self, child_el: T) -> &mut Self
1724        where
1725            T: Into<crate::generated::all::children::TableChild>,
1726        {
1727            let child_el = child_el.into();
1728            self.element.children_mut().push(child_el);
1729            self
1730        }
1731        /// Extend the list of children with an iterator of child elements.
1732        pub fn extend<I, T>(&mut self, iter: I) -> &mut Self
1733        where
1734            I: IntoIterator<Item = T>,
1735            T: Into<crate::generated::all::children::TableChild>,
1736        {
1737            let iter = iter.into_iter().map(|child_el| child_el.into());
1738            self.element.children_mut().extend(iter);
1739            self
1740        }
1741    }
1742}
html/generated/table.rs

html/generated/
table.rs
