html/generated/
thead.rs

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

html/generated/
thead.rs
