html/generated/
a.rs

1pub mod element {
2    /// The HTML `<a>` element
3    ///
4    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a)
5    #[doc(alias = "a")]
6    #[non_exhaustive]
7    #[derive(PartialEq, Clone, Default)]
8    pub struct Anchor {
9        sys: html_sys::text::Anchor,
10        children: Vec<super::child::AnchorChild>,
11    }
12    impl Anchor {
13        /// Create a new builder
14        pub fn builder() -> super::builder::AnchorBuilder {
15            super::builder::AnchorBuilder::new(Default::default())
16        }
17    }
18    impl Anchor {
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 Anchor {
29        /// Get the value of the `href` attribute
30        pub fn href(&self) -> std::option::Option<&str> {
31            self.sys.href.as_deref()
32        }
33        /// Set the value of the `href` attribute
34        pub fn set_href(
35            &mut self,
36            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
37        ) {
38            self.sys.href = value.map(|v| v.into());
39        }
40        /// Get the value of the `target` attribute
41        pub fn target(&self) -> std::option::Option<&str> {
42            self.sys.target.as_deref()
43        }
44        /// Set the value of the `target` attribute
45        pub fn set_target(
46            &mut self,
47            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
48        ) {
49            self.sys.target = value.map(|v| v.into());
50        }
51        /// Get the value of the `download` attribute
52        pub fn download(&self) -> std::option::Option<&str> {
53            self.sys.download.as_deref()
54        }
55        /// Set the value of the `download` attribute
56        pub fn set_download(
57            &mut self,
58            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
59        ) {
60            self.sys.download = value.map(|v| v.into());
61        }
62        /// Get the value of the `ping` attribute
63        pub fn ping(&self) -> std::option::Option<&str> {
64            self.sys.ping.as_deref()
65        }
66        /// Set the value of the `ping` attribute
67        pub fn set_ping(
68            &mut self,
69            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
70        ) {
71            self.sys.ping = value.map(|v| v.into());
72        }
73        /// Get the value of the `rel` attribute
74        pub fn rel(&self) -> std::option::Option<&str> {
75            self.sys.rel.as_deref()
76        }
77        /// Set the value of the `rel` attribute
78        pub fn set_rel(
79            &mut self,
80            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
81        ) {
82            self.sys.rel = value.map(|v| v.into());
83        }
84        /// Get the value of the `hreflang` attribute
85        pub fn hreflang(&self) -> std::option::Option<&str> {
86            self.sys.hreflang.as_deref()
87        }
88        /// Set the value of the `hreflang` attribute
89        pub fn set_hreflang(
90            &mut self,
91            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
92        ) {
93            self.sys.hreflang = value.map(|v| v.into());
94        }
95        /// Get the value of the `type` attribute
96        pub fn type_(&self) -> std::option::Option<&str> {
97            self.sys.type_.as_deref()
98        }
99        /// Set the value of the `type` attribute
100        pub fn set_type_(
101            &mut self,
102            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
103        ) {
104            self.sys.type_ = value.map(|v| v.into());
105        }
106        /// Get the value of the `referrerpolicy` attribute
107        pub fn referrerpolicy(&self) -> std::option::Option<&str> {
108            self.sys.referrerpolicy.as_deref()
109        }
110        /// Set the value of the `referrerpolicy` attribute
111        pub fn set_referrerpolicy(
112            &mut self,
113            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
114        ) {
115            self.sys.referrerpolicy = value.map(|v| v.into());
116        }
117        /// Get the value of the `role` attribute
118        pub fn role(&self) -> std::option::Option<&str> {
119            self.sys.role.as_deref()
120        }
121        /// Set the value of the `role` attribute
122        pub fn set_role(
123            &mut self,
124            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
125        ) {
126            self.sys.role = value.map(|v| v.into());
127        }
128        /// Get the value of the `aria-activedescendant` attribute
129        pub fn aria_active_descendant_element(&self) -> std::option::Option<&str> {
130            self.sys.aria_active_descendant_element.as_deref()
131        }
132        /// Set the value of the `aria-activedescendant` attribute
133        pub fn set_aria_active_descendant_element(
134            &mut self,
135            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
136        ) {
137            self.sys.aria_active_descendant_element = value.map(|v| v.into());
138        }
139        /// Get the value of the `aria-atomic` attribute
140        pub fn aria_atomic(&self) -> bool {
141            self.sys.aria_atomic
142        }
143        /// Set the value of the `aria-atomic` attribute
144        pub fn set_aria_atomic(&mut self, value: bool) {
145            self.sys.aria_atomic = value;
146        }
147        /// Get the value of the `aria-autocomplete` attribute
148        pub fn aria_auto_complete(&self) -> std::option::Option<&str> {
149            self.sys.aria_auto_complete.as_deref()
150        }
151        /// Set the value of the `aria-autocomplete` attribute
152        pub fn set_aria_auto_complete(
153            &mut self,
154            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
155        ) {
156            self.sys.aria_auto_complete = value.map(|v| v.into());
157        }
158        /// Get the value of the `aria-braillelabel` attribute
159        pub fn aria_braille_label(&self) -> std::option::Option<&str> {
160            self.sys.aria_braille_label.as_deref()
161        }
162        /// Set the value of the `aria-braillelabel` attribute
163        pub fn set_aria_braille_label(
164            &mut self,
165            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
166        ) {
167            self.sys.aria_braille_label = value.map(|v| v.into());
168        }
169        /// Get the value of the `aria-brailleroledescription` attribute
170        pub fn aria_braille_role_description(&self) -> std::option::Option<&str> {
171            self.sys.aria_braille_role_description.as_deref()
172        }
173        /// Set the value of the `aria-brailleroledescription` attribute
174        pub fn set_aria_braille_role_description(
175            &mut self,
176            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
177        ) {
178            self.sys.aria_braille_role_description = value.map(|v| v.into());
179        }
180        /// Get the value of the `aria-busy` attribute
181        pub fn aria_busy(&self) -> bool {
182            self.sys.aria_busy
183        }
184        /// Set the value of the `aria-busy` attribute
185        pub fn set_aria_busy(&mut self, value: bool) {
186            self.sys.aria_busy = value;
187        }
188        /// Get the value of the `aria-checked` attribute
189        pub fn aria_checked(&self) -> std::option::Option<&str> {
190            self.sys.aria_checked.as_deref()
191        }
192        /// Set the value of the `aria-checked` attribute
193        pub fn set_aria_checked(
194            &mut self,
195            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
196        ) {
197            self.sys.aria_checked = value.map(|v| v.into());
198        }
199        /// Get the value of the `aria-colcount` attribute
200        pub fn aria_col_count(&self) -> std::option::Option<i64> {
201            self.sys.aria_col_count
202        }
203        /// Set the value of the `aria-colcount` attribute
204        pub fn set_aria_col_count(&mut self, value: std::option::Option<i64>) {
205            self.sys.aria_col_count = value;
206        }
207        /// Get the value of the `aria-colindex` attribute
208        pub fn aria_col_index(&self) -> std::option::Option<i64> {
209            self.sys.aria_col_index
210        }
211        /// Set the value of the `aria-colindex` attribute
212        pub fn set_aria_col_index(&mut self, value: std::option::Option<i64>) {
213            self.sys.aria_col_index = value;
214        }
215        /// Get the value of the `aria-colindextext` attribute
216        pub fn aria_col_index_text(&self) -> std::option::Option<&str> {
217            self.sys.aria_col_index_text.as_deref()
218        }
219        /// Set the value of the `aria-colindextext` attribute
220        pub fn set_aria_col_index_text(
221            &mut self,
222            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
223        ) {
224            self.sys.aria_col_index_text = value.map(|v| v.into());
225        }
226        /// Get the value of the `aria-colspan` attribute
227        pub fn aria_col_span(&self) -> std::option::Option<i64> {
228            self.sys.aria_col_span
229        }
230        /// Set the value of the `aria-colspan` attribute
231        pub fn set_aria_col_span(&mut self, value: std::option::Option<i64>) {
232            self.sys.aria_col_span = value;
233        }
234        /// Get the value of the `aria-controls` attribute
235        pub fn aria_controls_elements(&self) -> std::option::Option<&str> {
236            self.sys.aria_controls_elements.as_deref()
237        }
238        /// Set the value of the `aria-controls` attribute
239        pub fn set_aria_controls_elements(
240            &mut self,
241            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
242        ) {
243            self.sys.aria_controls_elements = value.map(|v| v.into());
244        }
245        /// Get the value of the `aria-current` attribute
246        pub fn aria_current(&self) -> std::option::Option<&str> {
247            self.sys.aria_current.as_deref()
248        }
249        /// Set the value of the `aria-current` attribute
250        pub fn set_aria_current(
251            &mut self,
252            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
253        ) {
254            self.sys.aria_current = value.map(|v| v.into());
255        }
256        /// Get the value of the `aria-describedby` attribute
257        pub fn aria_described_by_elements(&self) -> std::option::Option<&str> {
258            self.sys.aria_described_by_elements.as_deref()
259        }
260        /// Set the value of the `aria-describedby` attribute
261        pub fn set_aria_described_by_elements(
262            &mut self,
263            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
264        ) {
265            self.sys.aria_described_by_elements = value.map(|v| v.into());
266        }
267        /// Get the value of the `aria-description` attribute
268        pub fn aria_description(&self) -> std::option::Option<&str> {
269            self.sys.aria_description.as_deref()
270        }
271        /// Set the value of the `aria-description` attribute
272        pub fn set_aria_description(
273            &mut self,
274            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
275        ) {
276            self.sys.aria_description = value.map(|v| v.into());
277        }
278        /// Get the value of the `aria-details` attribute
279        pub fn aria_details_elements(&self) -> std::option::Option<&str> {
280            self.sys.aria_details_elements.as_deref()
281        }
282        /// Set the value of the `aria-details` attribute
283        pub fn set_aria_details_elements(
284            &mut self,
285            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
286        ) {
287            self.sys.aria_details_elements = value.map(|v| v.into());
288        }
289        /// Get the value of the `aria-disabled` attribute
290        pub fn aria_disabled(&self) -> bool {
291            self.sys.aria_disabled
292        }
293        /// Set the value of the `aria-disabled` attribute
294        pub fn set_aria_disabled(&mut self, value: bool) {
295            self.sys.aria_disabled = value;
296        }
297        /// Get the value of the `aria-dropeffect` attribute
298        pub fn aria_drop_effect(&self) -> std::option::Option<&str> {
299            self.sys.aria_drop_effect.as_deref()
300        }
301        /// Set the value of the `aria-dropeffect` attribute
302        pub fn set_aria_drop_effect(
303            &mut self,
304            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
305        ) {
306            self.sys.aria_drop_effect = value.map(|v| v.into());
307        }
308        /// Get the value of the `aria-errormessage` attribute
309        pub fn aria_error_message_elements(&self) -> std::option::Option<&str> {
310            self.sys.aria_error_message_elements.as_deref()
311        }
312        /// Set the value of the `aria-errormessage` attribute
313        pub fn set_aria_error_message_elements(
314            &mut self,
315            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
316        ) {
317            self.sys.aria_error_message_elements = value.map(|v| v.into());
318        }
319        /// Get the value of the `aria-expanded` attribute
320        pub fn aria_expanded(&self) -> bool {
321            self.sys.aria_expanded
322        }
323        /// Set the value of the `aria-expanded` attribute
324        pub fn set_aria_expanded(&mut self, value: bool) {
325            self.sys.aria_expanded = value;
326        }
327        /// Get the value of the `aria-flowto` attribute
328        pub fn aria_flow_to_elements(&self) -> std::option::Option<&str> {
329            self.sys.aria_flow_to_elements.as_deref()
330        }
331        /// Set the value of the `aria-flowto` attribute
332        pub fn set_aria_flow_to_elements(
333            &mut self,
334            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
335        ) {
336            self.sys.aria_flow_to_elements = value.map(|v| v.into());
337        }
338        /// Get the value of the `aria-grabbed` attribute
339        pub fn aria_grabbed(&self) -> bool {
340            self.sys.aria_grabbed
341        }
342        /// Set the value of the `aria-grabbed` attribute
343        pub fn set_aria_grabbed(&mut self, value: bool) {
344            self.sys.aria_grabbed = value;
345        }
346        /// Get the value of the `aria-haspopup` attribute
347        pub fn aria_has_popup(&self) -> std::option::Option<&str> {
348            self.sys.aria_has_popup.as_deref()
349        }
350        /// Set the value of the `aria-haspopup` attribute
351        pub fn set_aria_has_popup(
352            &mut self,
353            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
354        ) {
355            self.sys.aria_has_popup = value.map(|v| v.into());
356        }
357        /// Get the value of the `aria-hidden` attribute
358        pub fn aria_hidden(&self) -> bool {
359            self.sys.aria_hidden
360        }
361        /// Set the value of the `aria-hidden` attribute
362        pub fn set_aria_hidden(&mut self, value: bool) {
363            self.sys.aria_hidden = value;
364        }
365        /// Get the value of the `aria-invalid` attribute
366        pub fn aria_invalid(&self) -> std::option::Option<&str> {
367            self.sys.aria_invalid.as_deref()
368        }
369        /// Set the value of the `aria-invalid` attribute
370        pub fn set_aria_invalid(
371            &mut self,
372            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
373        ) {
374            self.sys.aria_invalid = value.map(|v| v.into());
375        }
376        /// Get the value of the `aria-keyshortcuts` attribute
377        pub fn aria_key_shortcuts(&self) -> std::option::Option<&str> {
378            self.sys.aria_key_shortcuts.as_deref()
379        }
380        /// Set the value of the `aria-keyshortcuts` attribute
381        pub fn set_aria_key_shortcuts(
382            &mut self,
383            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
384        ) {
385            self.sys.aria_key_shortcuts = value.map(|v| v.into());
386        }
387        /// Get the value of the `aria-label` attribute
388        pub fn aria_label(&self) -> std::option::Option<&str> {
389            self.sys.aria_label.as_deref()
390        }
391        /// Set the value of the `aria-label` attribute
392        pub fn set_aria_label(
393            &mut self,
394            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
395        ) {
396            self.sys.aria_label = value.map(|v| v.into());
397        }
398        /// Get the value of the `aria-labelledby` attribute
399        pub fn aria_labelled_by_elements(&self) -> std::option::Option<&str> {
400            self.sys.aria_labelled_by_elements.as_deref()
401        }
402        /// Set the value of the `aria-labelledby` attribute
403        pub fn set_aria_labelled_by_elements(
404            &mut self,
405            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
406        ) {
407            self.sys.aria_labelled_by_elements = value.map(|v| v.into());
408        }
409        /// Get the value of the `aria-level` attribute
410        pub fn aria_level(&self) -> std::option::Option<i64> {
411            self.sys.aria_level
412        }
413        /// Set the value of the `aria-level` attribute
414        pub fn set_aria_level(&mut self, value: std::option::Option<i64>) {
415            self.sys.aria_level = value;
416        }
417        /// Get the value of the `aria-live` attribute
418        pub fn aria_live(&self) -> std::option::Option<&str> {
419            self.sys.aria_live.as_deref()
420        }
421        /// Set the value of the `aria-live` attribute
422        pub fn set_aria_live(
423            &mut self,
424            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
425        ) {
426            self.sys.aria_live = value.map(|v| v.into());
427        }
428        /// Get the value of the `aria-modal` attribute
429        pub fn aria_modal(&self) -> bool {
430            self.sys.aria_modal
431        }
432        /// Set the value of the `aria-modal` attribute
433        pub fn set_aria_modal(&mut self, value: bool) {
434            self.sys.aria_modal = value;
435        }
436        /// Get the value of the `aria-multiline` attribute
437        pub fn aria_multi_line(&self) -> bool {
438            self.sys.aria_multi_line
439        }
440        /// Set the value of the `aria-multiline` attribute
441        pub fn set_aria_multi_line(&mut self, value: bool) {
442            self.sys.aria_multi_line = value;
443        }
444        /// Get the value of the `aria-multiselectable` attribute
445        pub fn aria_multi_selectable(&self) -> bool {
446            self.sys.aria_multi_selectable
447        }
448        /// Set the value of the `aria-multiselectable` attribute
449        pub fn set_aria_multi_selectable(&mut self, value: bool) {
450            self.sys.aria_multi_selectable = value;
451        }
452        /// Get the value of the `aria-orientation` attribute
453        pub fn aria_orientation(&self) -> std::option::Option<&str> {
454            self.sys.aria_orientation.as_deref()
455        }
456        /// Set the value of the `aria-orientation` attribute
457        pub fn set_aria_orientation(
458            &mut self,
459            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
460        ) {
461            self.sys.aria_orientation = value.map(|v| v.into());
462        }
463        /// Get the value of the `aria-owns` attribute
464        pub fn aria_owns_elements(&self) -> std::option::Option<&str> {
465            self.sys.aria_owns_elements.as_deref()
466        }
467        /// Set the value of the `aria-owns` attribute
468        pub fn set_aria_owns_elements(
469            &mut self,
470            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
471        ) {
472            self.sys.aria_owns_elements = value.map(|v| v.into());
473        }
474        /// Get the value of the `aria-placeholder` attribute
475        pub fn aria_placeholder(&self) -> std::option::Option<&str> {
476            self.sys.aria_placeholder.as_deref()
477        }
478        /// Set the value of the `aria-placeholder` attribute
479        pub fn set_aria_placeholder(
480            &mut self,
481            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
482        ) {
483            self.sys.aria_placeholder = value.map(|v| v.into());
484        }
485        /// Get the value of the `aria-posinset` attribute
486        pub fn aria_pos_in_set(&self) -> std::option::Option<i64> {
487            self.sys.aria_pos_in_set
488        }
489        /// Set the value of the `aria-posinset` attribute
490        pub fn set_aria_pos_in_set(&mut self, value: std::option::Option<i64>) {
491            self.sys.aria_pos_in_set = value;
492        }
493        /// Get the value of the `aria-pressed` attribute
494        pub fn aria_pressed(&self) -> std::option::Option<&str> {
495            self.sys.aria_pressed.as_deref()
496        }
497        /// Set the value of the `aria-pressed` attribute
498        pub fn set_aria_pressed(
499            &mut self,
500            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
501        ) {
502            self.sys.aria_pressed = value.map(|v| v.into());
503        }
504        /// Get the value of the `aria-readonly` attribute
505        pub fn aria_read_only(&self) -> bool {
506            self.sys.aria_read_only
507        }
508        /// Set the value of the `aria-readonly` attribute
509        pub fn set_aria_read_only(&mut self, value: bool) {
510            self.sys.aria_read_only = value;
511        }
512        /// Get the value of the `aria-relevant` attribute
513        pub fn aria_relevant(&self) -> std::option::Option<&str> {
514            self.sys.aria_relevant.as_deref()
515        }
516        /// Set the value of the `aria-relevant` attribute
517        pub fn set_aria_relevant(
518            &mut self,
519            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
520        ) {
521            self.sys.aria_relevant = value.map(|v| v.into());
522        }
523        /// Get the value of the `aria-required` attribute
524        pub fn aria_required(&self) -> bool {
525            self.sys.aria_required
526        }
527        /// Set the value of the `aria-required` attribute
528        pub fn set_aria_required(&mut self, value: bool) {
529            self.sys.aria_required = value;
530        }
531        /// Get the value of the `aria-roledescription` attribute
532        pub fn aria_role_description(&self) -> std::option::Option<&str> {
533            self.sys.aria_role_description.as_deref()
534        }
535        /// Set the value of the `aria-roledescription` attribute
536        pub fn set_aria_role_description(
537            &mut self,
538            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
539        ) {
540            self.sys.aria_role_description = value.map(|v| v.into());
541        }
542        /// Get the value of the `aria-rowcount` attribute
543        pub fn aria_row_count(&self) -> std::option::Option<i64> {
544            self.sys.aria_row_count
545        }
546        /// Set the value of the `aria-rowcount` attribute
547        pub fn set_aria_row_count(&mut self, value: std::option::Option<i64>) {
548            self.sys.aria_row_count = value;
549        }
550        /// Get the value of the `aria-rowindex` attribute
551        pub fn aria_row_index(&self) -> std::option::Option<i64> {
552            self.sys.aria_row_index
553        }
554        /// Set the value of the `aria-rowindex` attribute
555        pub fn set_aria_row_index(&mut self, value: std::option::Option<i64>) {
556            self.sys.aria_row_index = value;
557        }
558        /// Get the value of the `aria-rowindextext` attribute
559        pub fn aria_row_index_text(&self) -> std::option::Option<&str> {
560            self.sys.aria_row_index_text.as_deref()
561        }
562        /// Set the value of the `aria-rowindextext` attribute
563        pub fn set_aria_row_index_text(
564            &mut self,
565            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
566        ) {
567            self.sys.aria_row_index_text = value.map(|v| v.into());
568        }
569        /// Get the value of the `aria-rowspan` attribute
570        pub fn aria_row_span(&self) -> std::option::Option<i64> {
571            self.sys.aria_row_span
572        }
573        /// Set the value of the `aria-rowspan` attribute
574        pub fn set_aria_row_span(&mut self, value: std::option::Option<i64>) {
575            self.sys.aria_row_span = value;
576        }
577        /// Get the value of the `aria-selected` attribute
578        pub fn aria_selected(&self) -> bool {
579            self.sys.aria_selected
580        }
581        /// Set the value of the `aria-selected` attribute
582        pub fn set_aria_selected(&mut self, value: bool) {
583            self.sys.aria_selected = value;
584        }
585        /// Get the value of the `aria-setsize` attribute
586        pub fn aria_set_size(&self) -> std::option::Option<i64> {
587            self.sys.aria_set_size
588        }
589        /// Set the value of the `aria-setsize` attribute
590        pub fn set_aria_set_size(&mut self, value: std::option::Option<i64>) {
591            self.sys.aria_set_size = value;
592        }
593        /// Get the value of the `aria-sort` attribute
594        pub fn aria_sort(&self) -> std::option::Option<&str> {
595            self.sys.aria_sort.as_deref()
596        }
597        /// Set the value of the `aria-sort` attribute
598        pub fn set_aria_sort(
599            &mut self,
600            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
601        ) {
602            self.sys.aria_sort = value.map(|v| v.into());
603        }
604        /// Get the value of the `aria-valuemax` attribute
605        pub fn aria_value_max(&self) -> std::option::Option<f64> {
606            self.sys.aria_value_max
607        }
608        /// Set the value of the `aria-valuemax` attribute
609        pub fn set_aria_value_max(&mut self, value: std::option::Option<f64>) {
610            self.sys.aria_value_max = value;
611        }
612        /// Get the value of the `aria-valuemin` attribute
613        pub fn aria_value_min(&self) -> std::option::Option<f64> {
614            self.sys.aria_value_min
615        }
616        /// Set the value of the `aria-valuemin` attribute
617        pub fn set_aria_value_min(&mut self, value: std::option::Option<f64>) {
618            self.sys.aria_value_min = value;
619        }
620        /// Get the value of the `aria-valuenow` attribute
621        pub fn aria_value_now(&self) -> std::option::Option<f64> {
622            self.sys.aria_value_now
623        }
624        /// Set the value of the `aria-valuenow` attribute
625        pub fn set_aria_value_now(&mut self, value: std::option::Option<f64>) {
626            self.sys.aria_value_now = value;
627        }
628        /// Get the value of the `aria-valuetext` attribute
629        pub fn aria_value_text(&self) -> std::option::Option<&str> {
630            self.sys.aria_value_text.as_deref()
631        }
632        /// Set the value of the `aria-valuetext` attribute
633        pub fn set_aria_value_text(
634            &mut self,
635            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
636        ) {
637            self.sys.aria_value_text = value.map(|v| v.into());
638        }
639        /// Get the value of the `accesskey` attribute
640        pub fn access_key(&self) -> std::option::Option<&str> {
641            self.sys.access_key.as_deref()
642        }
643        /// Set the value of the `accesskey` attribute
644        pub fn set_access_key(
645            &mut self,
646            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
647        ) {
648            self.sys.access_key = value.map(|v| v.into());
649        }
650        /// Get the value of the `autocapitalize` attribute
651        pub fn auto_capitalize(&self) -> std::option::Option<&str> {
652            self.sys.auto_capitalize.as_deref()
653        }
654        /// Set the value of the `autocapitalize` attribute
655        pub fn set_auto_capitalize(
656            &mut self,
657            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
658        ) {
659            self.sys.auto_capitalize = value.map(|v| v.into());
660        }
661        /// Get the value of the `autofocus` attribute
662        pub fn autofocus(&self) -> bool {
663            self.sys.autofocus
664        }
665        /// Set the value of the `autofocus` attribute
666        pub fn set_autofocus(&mut self, value: bool) {
667            self.sys.autofocus = value;
668        }
669        /// Get the value of the `class` attribute
670        pub fn class(&self) -> std::option::Option<&str> {
671            self.sys.class.as_deref()
672        }
673        /// Set the value of the `class` attribute
674        pub fn set_class(
675            &mut self,
676            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
677        ) {
678            self.sys.class = value.map(|v| v.into());
679        }
680        /// Get the value of the `contenteditable` attribute
681        pub fn content_editable(&self) -> std::option::Option<&str> {
682            self.sys.content_editable.as_deref()
683        }
684        /// Set the value of the `contenteditable` attribute
685        pub fn set_content_editable(
686            &mut self,
687            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
688        ) {
689            self.sys.content_editable = value.map(|v| v.into());
690        }
691        /// Get the value of the `dir` attribute
692        pub fn direction(&self) -> std::option::Option<&str> {
693            self.sys.direction.as_deref()
694        }
695        /// Set the value of the `dir` attribute
696        pub fn set_direction(
697            &mut self,
698            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
699        ) {
700            self.sys.direction = value.map(|v| v.into());
701        }
702        /// Get the value of the `draggable` attribute
703        pub fn draggable(&self) -> bool {
704            self.sys.draggable
705        }
706        /// Set the value of the `draggable` attribute
707        pub fn set_draggable(&mut self, value: bool) {
708            self.sys.draggable = value;
709        }
710        /// Get the value of the `enterkeyhint` attribute
711        pub fn enter_key_hint(&self) -> std::option::Option<&str> {
712            self.sys.enter_key_hint.as_deref()
713        }
714        /// Set the value of the `enterkeyhint` attribute
715        pub fn set_enter_key_hint(
716            &mut self,
717            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
718        ) {
719            self.sys.enter_key_hint = value.map(|v| v.into());
720        }
721        /// Get the value of the `exportparts` attribute
722        pub fn export_parts(&self) -> std::option::Option<&str> {
723            self.sys.export_parts.as_deref()
724        }
725        /// Set the value of the `exportparts` attribute
726        pub fn set_export_parts(
727            &mut self,
728            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
729        ) {
730            self.sys.export_parts = value.map(|v| v.into());
731        }
732        /// Get the value of the `hidden` attribute
733        pub fn hidden(&self) -> std::option::Option<&str> {
734            self.sys.hidden.as_deref()
735        }
736        /// Set the value of the `hidden` attribute
737        pub fn set_hidden(
738            &mut self,
739            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
740        ) {
741            self.sys.hidden = value.map(|v| v.into());
742        }
743        /// Get the value of the `id` attribute
744        pub fn id(&self) -> std::option::Option<&str> {
745            self.sys.id.as_deref()
746        }
747        /// Set the value of the `id` attribute
748        pub fn set_id(
749            &mut self,
750            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
751        ) {
752            self.sys.id = value.map(|v| v.into());
753        }
754        /// Get the value of the `inert` attribute
755        pub fn inert(&self) -> bool {
756            self.sys.inert
757        }
758        /// Set the value of the `inert` attribute
759        pub fn set_inert(&mut self, value: bool) {
760            self.sys.inert = value;
761        }
762        /// Get the value of the `inputmode` attribute
763        pub fn input_mode(&self) -> std::option::Option<&str> {
764            self.sys.input_mode.as_deref()
765        }
766        /// Set the value of the `inputmode` attribute
767        pub fn set_input_mode(
768            &mut self,
769            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
770        ) {
771            self.sys.input_mode = value.map(|v| v.into());
772        }
773        /// Get the value of the `is` attribute
774        pub fn is_(&self) -> std::option::Option<&str> {
775            self.sys.is_.as_deref()
776        }
777        /// Set the value of the `is` attribute
778        pub fn set_is_(
779            &mut self,
780            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
781        ) {
782            self.sys.is_ = value.map(|v| v.into());
783        }
784        /// Get the value of the `itemid` attribute
785        pub fn item_id(&self) -> std::option::Option<&str> {
786            self.sys.item_id.as_deref()
787        }
788        /// Set the value of the `itemid` attribute
789        pub fn set_item_id(
790            &mut self,
791            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
792        ) {
793            self.sys.item_id = value.map(|v| v.into());
794        }
795        /// Get the value of the `itemprop` attribute
796        pub fn item_prop(&self) -> std::option::Option<&str> {
797            self.sys.item_prop.as_deref()
798        }
799        /// Set the value of the `itemprop` attribute
800        pub fn set_item_prop(
801            &mut self,
802            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
803        ) {
804            self.sys.item_prop = value.map(|v| v.into());
805        }
806        /// Get the value of the `itemref` attribute
807        pub fn item_ref(&self) -> std::option::Option<&str> {
808            self.sys.item_ref.as_deref()
809        }
810        /// Set the value of the `itemref` attribute
811        pub fn set_item_ref(
812            &mut self,
813            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
814        ) {
815            self.sys.item_ref = value.map(|v| v.into());
816        }
817        /// Get the value of the `itemscope` attribute
818        pub fn item_scope(&self) -> std::option::Option<&str> {
819            self.sys.item_scope.as_deref()
820        }
821        /// Set the value of the `itemscope` attribute
822        pub fn set_item_scope(
823            &mut self,
824            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
825        ) {
826            self.sys.item_scope = value.map(|v| v.into());
827        }
828        /// Get the value of the `itemtype` attribute
829        pub fn item_type(&self) -> std::option::Option<&str> {
830            self.sys.item_type.as_deref()
831        }
832        /// Set the value of the `itemtype` attribute
833        pub fn set_item_type(
834            &mut self,
835            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
836        ) {
837            self.sys.item_type = value.map(|v| v.into());
838        }
839        /// Get the value of the `lang` attribute
840        pub fn lang(&self) -> std::option::Option<&str> {
841            self.sys.lang.as_deref()
842        }
843        /// Set the value of the `lang` attribute
844        pub fn set_lang(
845            &mut self,
846            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
847        ) {
848            self.sys.lang = value.map(|v| v.into());
849        }
850        /// Get the value of the `nonce` attribute
851        pub fn nonce(&self) -> std::option::Option<&str> {
852            self.sys.nonce.as_deref()
853        }
854        /// Set the value of the `nonce` attribute
855        pub fn set_nonce(
856            &mut self,
857            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
858        ) {
859            self.sys.nonce = value.map(|v| v.into());
860        }
861        /// Get the value of the `part` attribute
862        pub fn part(&self) -> std::option::Option<&str> {
863            self.sys.part.as_deref()
864        }
865        /// Set the value of the `part` attribute
866        pub fn set_part(
867            &mut self,
868            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
869        ) {
870            self.sys.part = value.map(|v| v.into());
871        }
872        /// Get the value of the `slot` attribute
873        pub fn slot(&self) -> std::option::Option<&str> {
874            self.sys.slot.as_deref()
875        }
876        /// Set the value of the `slot` attribute
877        pub fn set_slot(
878            &mut self,
879            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
880        ) {
881            self.sys.slot = value.map(|v| v.into());
882        }
883        /// Get the value of the `spellcheck` attribute
884        pub fn spellcheck(&self) -> std::option::Option<&str> {
885            self.sys.spellcheck.as_deref()
886        }
887        /// Set the value of the `spellcheck` attribute
888        pub fn set_spellcheck(
889            &mut self,
890            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
891        ) {
892            self.sys.spellcheck = value.map(|v| v.into());
893        }
894        /// Get the value of the `style` attribute
895        pub fn style(&self) -> std::option::Option<&str> {
896            self.sys.style.as_deref()
897        }
898        /// Set the value of the `style` attribute
899        pub fn set_style(
900            &mut self,
901            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
902        ) {
903            self.sys.style = value.map(|v| v.into());
904        }
905        /// Get the value of the `tabindex` attribute
906        pub fn tab_index(&self) -> std::option::Option<i64> {
907            self.sys.tab_index
908        }
909        /// Set the value of the `tabindex` attribute
910        pub fn set_tab_index(&mut self, value: std::option::Option<i64>) {
911            self.sys.tab_index = value;
912        }
913        /// Get the value of the `title` attribute
914        pub fn title(&self) -> std::option::Option<&str> {
915            self.sys.title.as_deref()
916        }
917        /// Set the value of the `title` attribute
918        pub fn set_title(
919            &mut self,
920            value: std::option::Option<impl Into<std::borrow::Cow<'static, str>>>,
921        ) {
922            self.sys.title = value.map(|v| v.into());
923        }
924        /// Get the value of the `translate` attribute
925        pub fn translate(&self) -> bool {
926            self.sys.translate
927        }
928        /// Set the value of the `translate` attribute
929        pub fn set_translate(&mut self, value: bool) {
930            self.sys.translate = value;
931        }
932    }
933    impl Anchor {
934        /// Access the element's children
935        pub fn children(&self) -> &[super::child::AnchorChild] {
936            self.children.as_ref()
937        }
938        /// Mutably access the element's children
939        pub fn children_mut(&mut self) -> &mut Vec<super::child::AnchorChild> {
940            &mut self.children
941        }
942    }
943    impl crate::Render for Anchor {
944        fn render(
945            &self,
946            f: &mut std::fmt::Formatter<'_>,
947            depth: usize,
948        ) -> std::fmt::Result {
949            write!(f, "{:level$}", "", level = depth * 4)?;
950            html_sys::RenderElement::write_opening_tag(&self.sys, f)?;
951            if !self.children.is_empty() {
952                write!(f, "\n")?;
953            }
954            for el in &self.children {
955                crate::Render::render(&el, f, depth)?;
956                write!(f, "\n")?;
957            }
958            write!(f, "{:level$}", "", level = depth * 4)?;
959            html_sys::RenderElement::write_closing_tag(&self.sys, f)?;
960            Ok(())
961        }
962    }
963    impl std::fmt::Debug for Anchor {
964        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
965            crate::Render::render(self, f, 0)?;
966            Ok(())
967        }
968    }
969    impl std::fmt::Display for Anchor {
970        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
971            html_sys::RenderElement::write_opening_tag(&self.sys, f)?;
972            for el in &self.children {
973                write!(f, "{el}")?;
974            }
975            html_sys::RenderElement::write_closing_tag(&self.sys, f)?;
976            Ok(())
977        }
978    }
979    impl crate::HtmlElement for Anchor {}
980    impl crate::FlowContent for Anchor {}
981    impl crate::PhrasingContent for Anchor {}
982    impl crate::InteractiveContent for Anchor {}
983    impl crate::PalpableContent for Anchor {}
984    impl std::convert::Into<html_sys::text::Anchor> for Anchor {
985        fn into(self) -> html_sys::text::Anchor {
986            self.sys
987        }
988    }
989    impl From<html_sys::text::Anchor> for Anchor {
990        fn from(sys: html_sys::text::Anchor) -> Self {
991            Self { sys, children: vec![] }
992        }
993    }
994}
995pub mod child {
996    /// The permitted child items for the `Anchor` element
997    #[derive(PartialEq, Clone)]
998    pub enum AnchorChild {
999        /// The Abbreviation element
1000        Abbreviation(crate::generated::all::Abbreviation),
1001        /// The Address element
1002        Address(crate::generated::all::Address),
1003        /// The Anchor element
1004        Anchor(crate::generated::all::Anchor),
1005        /// The Article element
1006        Article(crate::generated::all::Article),
1007        /// The Aside element
1008        Aside(crate::generated::all::Aside),
1009        /// The Audio element
1010        Audio(crate::generated::all::Audio),
1011        /// The Base element
1012        Base(crate::generated::all::Base),
1013        /// The BidirectionalIsolate element
1014        BidirectionalIsolate(crate::generated::all::BidirectionalIsolate),
1015        /// The BidirectionalTextOverride element
1016        BidirectionalTextOverride(crate::generated::all::BidirectionalTextOverride),
1017        /// The BlockQuote element
1018        BlockQuote(crate::generated::all::BlockQuote),
1019        /// The Body element
1020        Body(crate::generated::all::Body),
1021        /// The Bold element
1022        Bold(crate::generated::all::Bold),
1023        /// The Button element
1024        Button(crate::generated::all::Button),
1025        /// The Canvas element
1026        Canvas(crate::generated::all::Canvas),
1027        /// The Caption element
1028        Caption(crate::generated::all::Caption),
1029        /// The Cite element
1030        Cite(crate::generated::all::Cite),
1031        /// The Code element
1032        Code(crate::generated::all::Code),
1033        /// The Data element
1034        Data(crate::generated::all::Data),
1035        /// The DataList element
1036        DataList(crate::generated::all::DataList),
1037        /// The Definition element
1038        Definition(crate::generated::all::Definition),
1039        /// The DeletedText element
1040        DeletedText(crate::generated::all::DeletedText),
1041        /// The DescriptionDetails element
1042        DescriptionDetails(crate::generated::all::DescriptionDetails),
1043        /// The DescriptionList element
1044        DescriptionList(crate::generated::all::DescriptionList),
1045        /// The DescriptionTerm element
1046        DescriptionTerm(crate::generated::all::DescriptionTerm),
1047        /// The Details element
1048        Details(crate::generated::all::Details),
1049        /// The Dialog element
1050        Dialog(crate::generated::all::Dialog),
1051        /// The Division element
1052        Division(crate::generated::all::Division),
1053        /// The Embed element
1054        Embed(crate::generated::all::Embed),
1055        /// The Emphasis element
1056        Emphasis(crate::generated::all::Emphasis),
1057        /// The Fieldset element
1058        Fieldset(crate::generated::all::Fieldset),
1059        /// The Figure element
1060        Figure(crate::generated::all::Figure),
1061        /// The FigureCaption element
1062        FigureCaption(crate::generated::all::FigureCaption),
1063        /// The Footer element
1064        Footer(crate::generated::all::Footer),
1065        /// The Form element
1066        Form(crate::generated::all::Form),
1067        /// The Head element
1068        Head(crate::generated::all::Head),
1069        /// The Header element
1070        Header(crate::generated::all::Header),
1071        /// The Heading1 element
1072        Heading1(crate::generated::all::Heading1),
1073        /// The Heading2 element
1074        Heading2(crate::generated::all::Heading2),
1075        /// The Heading3 element
1076        Heading3(crate::generated::all::Heading3),
1077        /// The Heading4 element
1078        Heading4(crate::generated::all::Heading4),
1079        /// The Heading5 element
1080        Heading5(crate::generated::all::Heading5),
1081        /// The Heading6 element
1082        Heading6(crate::generated::all::Heading6),
1083        /// The HeadingGroup element
1084        HeadingGroup(crate::generated::all::HeadingGroup),
1085        /// The Html element
1086        Html(crate::generated::all::Html),
1087        /// The Iframe element
1088        Iframe(crate::generated::all::Iframe),
1089        /// The Image element
1090        Image(crate::generated::all::Image),
1091        /// The ImageMap element
1092        ImageMap(crate::generated::all::ImageMap),
1093        /// The ImageMapArea element
1094        ImageMapArea(crate::generated::all::ImageMapArea),
1095        /// The Input element
1096        Input(crate::generated::all::Input),
1097        /// The InsertedText element
1098        InsertedText(crate::generated::all::InsertedText),
1099        /// The Italic element
1100        Italic(crate::generated::all::Italic),
1101        /// The KeyboardInput element
1102        KeyboardInput(crate::generated::all::KeyboardInput),
1103        /// The Label element
1104        Label(crate::generated::all::Label),
1105        /// The Legend element
1106        Legend(crate::generated::all::Legend),
1107        /// The LineBreak element
1108        LineBreak(crate::generated::all::LineBreak),
1109        /// The LineBreakOpportunity element
1110        LineBreakOpportunity(crate::generated::all::LineBreakOpportunity),
1111        /// The Link element
1112        Link(crate::generated::all::Link),
1113        /// The ListItem element
1114        ListItem(crate::generated::all::ListItem),
1115        /// The Main element
1116        Main(crate::generated::all::Main),
1117        /// The MarkText element
1118        MarkText(crate::generated::all::MarkText),
1119        /// The MediaSource element
1120        MediaSource(crate::generated::all::MediaSource),
1121        /// The Menu element
1122        Menu(crate::generated::all::Menu),
1123        /// The Meta element
1124        Meta(crate::generated::all::Meta),
1125        /// The Meter element
1126        Meter(crate::generated::all::Meter),
1127        /// The Navigation element
1128        Navigation(crate::generated::all::Navigation),
1129        /// The NoScript element
1130        NoScript(crate::generated::all::NoScript),
1131        /// The Object element
1132        Object(crate::generated::all::Object),
1133        /// The Option element
1134        Option(crate::generated::all::Option),
1135        /// The OptionGroup element
1136        OptionGroup(crate::generated::all::OptionGroup),
1137        /// The OrderedList element
1138        OrderedList(crate::generated::all::OrderedList),
1139        /// The Output element
1140        Output(crate::generated::all::Output),
1141        /// The Paragraph element
1142        Paragraph(crate::generated::all::Paragraph),
1143        /// The Picture element
1144        Picture(crate::generated::all::Picture),
1145        /// The PreformattedText element
1146        PreformattedText(crate::generated::all::PreformattedText),
1147        /// The Progress element
1148        Progress(crate::generated::all::Progress),
1149        /// The Quotation element
1150        Quotation(crate::generated::all::Quotation),
1151        /// The RubyAnnotation element
1152        RubyAnnotation(crate::generated::all::RubyAnnotation),
1153        /// The RubyFallbackParenthesis element
1154        RubyFallbackParenthesis(crate::generated::all::RubyFallbackParenthesis),
1155        /// The RubyText element
1156        RubyText(crate::generated::all::RubyText),
1157        /// The SampleOutput element
1158        SampleOutput(crate::generated::all::SampleOutput),
1159        /// The Script element
1160        Script(crate::generated::all::Script),
1161        /// The Search element
1162        Search(crate::generated::all::Search),
1163        /// The Section element
1164        Section(crate::generated::all::Section),
1165        /// The Select element
1166        Select(crate::generated::all::Select),
1167        /// The SideComment element
1168        SideComment(crate::generated::all::SideComment),
1169        /// The Slot element
1170        Slot(crate::generated::all::Slot),
1171        /// The Span element
1172        Span(crate::generated::all::Span),
1173        /// The StrikeThrough element
1174        StrikeThrough(crate::generated::all::StrikeThrough),
1175        /// The Strong element
1176        Strong(crate::generated::all::Strong),
1177        /// The Style element
1178        Style(crate::generated::all::Style),
1179        /// The SubScript element
1180        SubScript(crate::generated::all::SubScript),
1181        /// The Summary element
1182        Summary(crate::generated::all::Summary),
1183        /// The SuperScript element
1184        SuperScript(crate::generated::all::SuperScript),
1185        /// The Table element
1186        Table(crate::generated::all::Table),
1187        /// The TableBody element
1188        TableBody(crate::generated::all::TableBody),
1189        /// The TableCell element
1190        TableCell(crate::generated::all::TableCell),
1191        /// The TableColumn element
1192        TableColumn(crate::generated::all::TableColumn),
1193        /// The TableColumnGroup element
1194        TableColumnGroup(crate::generated::all::TableColumnGroup),
1195        /// The TableFoot element
1196        TableFoot(crate::generated::all::TableFoot),
1197        /// The TableHead element
1198        TableHead(crate::generated::all::TableHead),
1199        /// The TableHeader element
1200        TableHeader(crate::generated::all::TableHeader),
1201        /// The TableRow element
1202        TableRow(crate::generated::all::TableRow),
1203        /// The Template element
1204        Template(crate::generated::all::Template),
1205        /// The Text element
1206        Text(std::borrow::Cow<'static, str>),
1207        /// The TextArea element
1208        TextArea(crate::generated::all::TextArea),
1209        /// The TextTrack element
1210        TextTrack(crate::generated::all::TextTrack),
1211        /// The ThematicBreak element
1212        ThematicBreak(crate::generated::all::ThematicBreak),
1213        /// The Time element
1214        Time(crate::generated::all::Time),
1215        /// The Title element
1216        Title(crate::generated::all::Title),
1217        /// The Underline element
1218        Underline(crate::generated::all::Underline),
1219        /// The UnorderedList element
1220        UnorderedList(crate::generated::all::UnorderedList),
1221        /// The Variable element
1222        Variable(crate::generated::all::Variable),
1223        /// The Video element
1224        Video(crate::generated::all::Video),
1225    }
1226    impl std::convert::From<crate::generated::all::Abbreviation> for AnchorChild {
1227        fn from(value: crate::generated::all::Abbreviation) -> Self {
1228            Self::Abbreviation(value)
1229        }
1230    }
1231    impl std::convert::From<crate::generated::all::Address> for AnchorChild {
1232        fn from(value: crate::generated::all::Address) -> Self {
1233            Self::Address(value)
1234        }
1235    }
1236    impl std::convert::From<crate::generated::all::Anchor> for AnchorChild {
1237        fn from(value: crate::generated::all::Anchor) -> Self {
1238            Self::Anchor(value)
1239        }
1240    }
1241    impl std::convert::From<crate::generated::all::Article> for AnchorChild {
1242        fn from(value: crate::generated::all::Article) -> Self {
1243            Self::Article(value)
1244        }
1245    }
1246    impl std::convert::From<crate::generated::all::Aside> for AnchorChild {
1247        fn from(value: crate::generated::all::Aside) -> Self {
1248            Self::Aside(value)
1249        }
1250    }
1251    impl std::convert::From<crate::generated::all::Audio> for AnchorChild {
1252        fn from(value: crate::generated::all::Audio) -> Self {
1253            Self::Audio(value)
1254        }
1255    }
1256    impl std::convert::From<crate::generated::all::Base> for AnchorChild {
1257        fn from(value: crate::generated::all::Base) -> Self {
1258            Self::Base(value)
1259        }
1260    }
1261    impl std::convert::From<crate::generated::all::BidirectionalIsolate>
1262    for AnchorChild {
1263        fn from(value: crate::generated::all::BidirectionalIsolate) -> Self {
1264            Self::BidirectionalIsolate(value)
1265        }
1266    }
1267    impl std::convert::From<crate::generated::all::BidirectionalTextOverride>
1268    for AnchorChild {
1269        fn from(value: crate::generated::all::BidirectionalTextOverride) -> Self {
1270            Self::BidirectionalTextOverride(value)
1271        }
1272    }
1273    impl std::convert::From<crate::generated::all::BlockQuote> for AnchorChild {
1274        fn from(value: crate::generated::all::BlockQuote) -> Self {
1275            Self::BlockQuote(value)
1276        }
1277    }
1278    impl std::convert::From<crate::generated::all::Body> for AnchorChild {
1279        fn from(value: crate::generated::all::Body) -> Self {
1280            Self::Body(value)
1281        }
1282    }
1283    impl std::convert::From<crate::generated::all::Bold> for AnchorChild {
1284        fn from(value: crate::generated::all::Bold) -> Self {
1285            Self::Bold(value)
1286        }
1287    }
1288    impl std::convert::From<crate::generated::all::Button> for AnchorChild {
1289        fn from(value: crate::generated::all::Button) -> Self {
1290            Self::Button(value)
1291        }
1292    }
1293    impl std::convert::From<crate::generated::all::Canvas> for AnchorChild {
1294        fn from(value: crate::generated::all::Canvas) -> Self {
1295            Self::Canvas(value)
1296        }
1297    }
1298    impl std::convert::From<crate::generated::all::Caption> for AnchorChild {
1299        fn from(value: crate::generated::all::Caption) -> Self {
1300            Self::Caption(value)
1301        }
1302    }
1303    impl std::convert::From<crate::generated::all::Cite> for AnchorChild {
1304        fn from(value: crate::generated::all::Cite) -> Self {
1305            Self::Cite(value)
1306        }
1307    }
1308    impl std::convert::From<crate::generated::all::Code> for AnchorChild {
1309        fn from(value: crate::generated::all::Code) -> Self {
1310            Self::Code(value)
1311        }
1312    }
1313    impl std::convert::From<crate::generated::all::Data> for AnchorChild {
1314        fn from(value: crate::generated::all::Data) -> Self {
1315            Self::Data(value)
1316        }
1317    }
1318    impl std::convert::From<crate::generated::all::DataList> for AnchorChild {
1319        fn from(value: crate::generated::all::DataList) -> Self {
1320            Self::DataList(value)
1321        }
1322    }
1323    impl std::convert::From<crate::generated::all::Definition> for AnchorChild {
1324        fn from(value: crate::generated::all::Definition) -> Self {
1325            Self::Definition(value)
1326        }
1327    }
1328    impl std::convert::From<crate::generated::all::DeletedText> for AnchorChild {
1329        fn from(value: crate::generated::all::DeletedText) -> Self {
1330            Self::DeletedText(value)
1331        }
1332    }
1333    impl std::convert::From<crate::generated::all::DescriptionDetails> for AnchorChild {
1334        fn from(value: crate::generated::all::DescriptionDetails) -> Self {
1335            Self::DescriptionDetails(value)
1336        }
1337    }
1338    impl std::convert::From<crate::generated::all::DescriptionList> for AnchorChild {
1339        fn from(value: crate::generated::all::DescriptionList) -> Self {
1340            Self::DescriptionList(value)
1341        }
1342    }
1343    impl std::convert::From<crate::generated::all::DescriptionTerm> for AnchorChild {
1344        fn from(value: crate::generated::all::DescriptionTerm) -> Self {
1345            Self::DescriptionTerm(value)
1346        }
1347    }
1348    impl std::convert::From<crate::generated::all::Details> for AnchorChild {
1349        fn from(value: crate::generated::all::Details) -> Self {
1350            Self::Details(value)
1351        }
1352    }
1353    impl std::convert::From<crate::generated::all::Dialog> for AnchorChild {
1354        fn from(value: crate::generated::all::Dialog) -> Self {
1355            Self::Dialog(value)
1356        }
1357    }
1358    impl std::convert::From<crate::generated::all::Division> for AnchorChild {
1359        fn from(value: crate::generated::all::Division) -> Self {
1360            Self::Division(value)
1361        }
1362    }
1363    impl std::convert::From<crate::generated::all::Embed> for AnchorChild {
1364        fn from(value: crate::generated::all::Embed) -> Self {
1365            Self::Embed(value)
1366        }
1367    }
1368    impl std::convert::From<crate::generated::all::Emphasis> for AnchorChild {
1369        fn from(value: crate::generated::all::Emphasis) -> Self {
1370            Self::Emphasis(value)
1371        }
1372    }
1373    impl std::convert::From<crate::generated::all::Fieldset> for AnchorChild {
1374        fn from(value: crate::generated::all::Fieldset) -> Self {
1375            Self::Fieldset(value)
1376        }
1377    }
1378    impl std::convert::From<crate::generated::all::Figure> for AnchorChild {
1379        fn from(value: crate::generated::all::Figure) -> Self {
1380            Self::Figure(value)
1381        }
1382    }
1383    impl std::convert::From<crate::generated::all::FigureCaption> for AnchorChild {
1384        fn from(value: crate::generated::all::FigureCaption) -> Self {
1385            Self::FigureCaption(value)
1386        }
1387    }
1388    impl std::convert::From<crate::generated::all::Footer> for AnchorChild {
1389        fn from(value: crate::generated::all::Footer) -> Self {
1390            Self::Footer(value)
1391        }
1392    }
1393    impl std::convert::From<crate::generated::all::Form> for AnchorChild {
1394        fn from(value: crate::generated::all::Form) -> Self {
1395            Self::Form(value)
1396        }
1397    }
1398    impl std::convert::From<crate::generated::all::Head> for AnchorChild {
1399        fn from(value: crate::generated::all::Head) -> Self {
1400            Self::Head(value)
1401        }
1402    }
1403    impl std::convert::From<crate::generated::all::Header> for AnchorChild {
1404        fn from(value: crate::generated::all::Header) -> Self {
1405            Self::Header(value)
1406        }
1407    }
1408    impl std::convert::From<crate::generated::all::Heading1> for AnchorChild {
1409        fn from(value: crate::generated::all::Heading1) -> Self {
1410            Self::Heading1(value)
1411        }
1412    }
1413    impl std::convert::From<crate::generated::all::Heading2> for AnchorChild {
1414        fn from(value: crate::generated::all::Heading2) -> Self {
1415            Self::Heading2(value)
1416        }
1417    }
1418    impl std::convert::From<crate::generated::all::Heading3> for AnchorChild {
1419        fn from(value: crate::generated::all::Heading3) -> Self {
1420            Self::Heading3(value)
1421        }
1422    }
1423    impl std::convert::From<crate::generated::all::Heading4> for AnchorChild {
1424        fn from(value: crate::generated::all::Heading4) -> Self {
1425            Self::Heading4(value)
1426        }
1427    }
1428    impl std::convert::From<crate::generated::all::Heading5> for AnchorChild {
1429        fn from(value: crate::generated::all::Heading5) -> Self {
1430            Self::Heading5(value)
1431        }
1432    }
1433    impl std::convert::From<crate::generated::all::Heading6> for AnchorChild {
1434        fn from(value: crate::generated::all::Heading6) -> Self {
1435            Self::Heading6(value)
1436        }
1437    }
1438    impl std::convert::From<crate::generated::all::HeadingGroup> for AnchorChild {
1439        fn from(value: crate::generated::all::HeadingGroup) -> Self {
1440            Self::HeadingGroup(value)
1441        }
1442    }
1443    impl std::convert::From<crate::generated::all::Html> for AnchorChild {
1444        fn from(value: crate::generated::all::Html) -> Self {
1445            Self::Html(value)
1446        }
1447    }
1448    impl std::convert::From<crate::generated::all::Iframe> for AnchorChild {
1449        fn from(value: crate::generated::all::Iframe) -> Self {
1450            Self::Iframe(value)
1451        }
1452    }
1453    impl std::convert::From<crate::generated::all::Image> for AnchorChild {
1454        fn from(value: crate::generated::all::Image) -> Self {
1455            Self::Image(value)
1456        }
1457    }
1458    impl std::convert::From<crate::generated::all::ImageMap> for AnchorChild {
1459        fn from(value: crate::generated::all::ImageMap) -> Self {
1460            Self::ImageMap(value)
1461        }
1462    }
1463    impl std::convert::From<crate::generated::all::ImageMapArea> for AnchorChild {
1464        fn from(value: crate::generated::all::ImageMapArea) -> Self {
1465            Self::ImageMapArea(value)
1466        }
1467    }
1468    impl std::convert::From<crate::generated::all::Input> for AnchorChild {
1469        fn from(value: crate::generated::all::Input) -> Self {
1470            Self::Input(value)
1471        }
1472    }
1473    impl std::convert::From<crate::generated::all::InsertedText> for AnchorChild {
1474        fn from(value: crate::generated::all::InsertedText) -> Self {
1475            Self::InsertedText(value)
1476        }
1477    }
1478    impl std::convert::From<crate::generated::all::Italic> for AnchorChild {
1479        fn from(value: crate::generated::all::Italic) -> Self {
1480            Self::Italic(value)
1481        }
1482    }
1483    impl std::convert::From<crate::generated::all::KeyboardInput> for AnchorChild {
1484        fn from(value: crate::generated::all::KeyboardInput) -> Self {
1485            Self::KeyboardInput(value)
1486        }
1487    }
1488    impl std::convert::From<crate::generated::all::Label> for AnchorChild {
1489        fn from(value: crate::generated::all::Label) -> Self {
1490            Self::Label(value)
1491        }
1492    }
1493    impl std::convert::From<crate::generated::all::Legend> for AnchorChild {
1494        fn from(value: crate::generated::all::Legend) -> Self {
1495            Self::Legend(value)
1496        }
1497    }
1498    impl std::convert::From<crate::generated::all::LineBreak> for AnchorChild {
1499        fn from(value: crate::generated::all::LineBreak) -> Self {
1500            Self::LineBreak(value)
1501        }
1502    }
1503    impl std::convert::From<crate::generated::all::LineBreakOpportunity>
1504    for AnchorChild {
1505        fn from(value: crate::generated::all::LineBreakOpportunity) -> Self {
1506            Self::LineBreakOpportunity(value)
1507        }
1508    }
1509    impl std::convert::From<crate::generated::all::Link> for AnchorChild {
1510        fn from(value: crate::generated::all::Link) -> Self {
1511            Self::Link(value)
1512        }
1513    }
1514    impl std::convert::From<crate::generated::all::ListItem> for AnchorChild {
1515        fn from(value: crate::generated::all::ListItem) -> Self {
1516            Self::ListItem(value)
1517        }
1518    }
1519    impl std::convert::From<crate::generated::all::Main> for AnchorChild {
1520        fn from(value: crate::generated::all::Main) -> Self {
1521            Self::Main(value)
1522        }
1523    }
1524    impl std::convert::From<crate::generated::all::MarkText> for AnchorChild {
1525        fn from(value: crate::generated::all::MarkText) -> Self {
1526            Self::MarkText(value)
1527        }
1528    }
1529    impl std::convert::From<crate::generated::all::MediaSource> for AnchorChild {
1530        fn from(value: crate::generated::all::MediaSource) -> Self {
1531            Self::MediaSource(value)
1532        }
1533    }
1534    impl std::convert::From<crate::generated::all::Menu> for AnchorChild {
1535        fn from(value: crate::generated::all::Menu) -> Self {
1536            Self::Menu(value)
1537        }
1538    }
1539    impl std::convert::From<crate::generated::all::Meta> for AnchorChild {
1540        fn from(value: crate::generated::all::Meta) -> Self {
1541            Self::Meta(value)
1542        }
1543    }
1544    impl std::convert::From<crate::generated::all::Meter> for AnchorChild {
1545        fn from(value: crate::generated::all::Meter) -> Self {
1546            Self::Meter(value)
1547        }
1548    }
1549    impl std::convert::From<crate::generated::all::Navigation> for AnchorChild {
1550        fn from(value: crate::generated::all::Navigation) -> Self {
1551            Self::Navigation(value)
1552        }
1553    }
1554    impl std::convert::From<crate::generated::all::NoScript> for AnchorChild {
1555        fn from(value: crate::generated::all::NoScript) -> Self {
1556            Self::NoScript(value)
1557        }
1558    }
1559    impl std::convert::From<crate::generated::all::Object> for AnchorChild {
1560        fn from(value: crate::generated::all::Object) -> Self {
1561            Self::Object(value)
1562        }
1563    }
1564    impl std::convert::From<crate::generated::all::Option> for AnchorChild {
1565        fn from(value: crate::generated::all::Option) -> Self {
1566            Self::Option(value)
1567        }
1568    }
1569    impl std::convert::From<crate::generated::all::OptionGroup> for AnchorChild {
1570        fn from(value: crate::generated::all::OptionGroup) -> Self {
1571            Self::OptionGroup(value)
1572        }
1573    }
1574    impl std::convert::From<crate::generated::all::OrderedList> for AnchorChild {
1575        fn from(value: crate::generated::all::OrderedList) -> Self {
1576            Self::OrderedList(value)
1577        }
1578    }
1579    impl std::convert::From<crate::generated::all::Output> for AnchorChild {
1580        fn from(value: crate::generated::all::Output) -> Self {
1581            Self::Output(value)
1582        }
1583    }
1584    impl std::convert::From<crate::generated::all::Paragraph> for AnchorChild {
1585        fn from(value: crate::generated::all::Paragraph) -> Self {
1586            Self::Paragraph(value)
1587        }
1588    }
1589    impl std::convert::From<crate::generated::all::Picture> for AnchorChild {
1590        fn from(value: crate::generated::all::Picture) -> Self {
1591            Self::Picture(value)
1592        }
1593    }
1594    impl std::convert::From<crate::generated::all::PreformattedText> for AnchorChild {
1595        fn from(value: crate::generated::all::PreformattedText) -> Self {
1596            Self::PreformattedText(value)
1597        }
1598    }
1599    impl std::convert::From<crate::generated::all::Progress> for AnchorChild {
1600        fn from(value: crate::generated::all::Progress) -> Self {
1601            Self::Progress(value)
1602        }
1603    }
1604    impl std::convert::From<crate::generated::all::Quotation> for AnchorChild {
1605        fn from(value: crate::generated::all::Quotation) -> Self {
1606            Self::Quotation(value)
1607        }
1608    }
1609    impl std::convert::From<crate::generated::all::RubyAnnotation> for AnchorChild {
1610        fn from(value: crate::generated::all::RubyAnnotation) -> Self {
1611            Self::RubyAnnotation(value)
1612        }
1613    }
1614    impl std::convert::From<crate::generated::all::RubyFallbackParenthesis>
1615    for AnchorChild {
1616        fn from(value: crate::generated::all::RubyFallbackParenthesis) -> Self {
1617            Self::RubyFallbackParenthesis(value)
1618        }
1619    }
1620    impl std::convert::From<crate::generated::all::RubyText> for AnchorChild {
1621        fn from(value: crate::generated::all::RubyText) -> Self {
1622            Self::RubyText(value)
1623        }
1624    }
1625    impl std::convert::From<crate::generated::all::SampleOutput> for AnchorChild {
1626        fn from(value: crate::generated::all::SampleOutput) -> Self {
1627            Self::SampleOutput(value)
1628        }
1629    }
1630    impl std::convert::From<crate::generated::all::Script> for AnchorChild {
1631        fn from(value: crate::generated::all::Script) -> Self {
1632            Self::Script(value)
1633        }
1634    }
1635    impl std::convert::From<crate::generated::all::Search> for AnchorChild {
1636        fn from(value: crate::generated::all::Search) -> Self {
1637            Self::Search(value)
1638        }
1639    }
1640    impl std::convert::From<crate::generated::all::Section> for AnchorChild {
1641        fn from(value: crate::generated::all::Section) -> Self {
1642            Self::Section(value)
1643        }
1644    }
1645    impl std::convert::From<crate::generated::all::Select> for AnchorChild {
1646        fn from(value: crate::generated::all::Select) -> Self {
1647            Self::Select(value)
1648        }
1649    }
1650    impl std::convert::From<crate::generated::all::SideComment> for AnchorChild {
1651        fn from(value: crate::generated::all::SideComment) -> Self {
1652            Self::SideComment(value)
1653        }
1654    }
1655    impl std::convert::From<crate::generated::all::Slot> for AnchorChild {
1656        fn from(value: crate::generated::all::Slot) -> Self {
1657            Self::Slot(value)
1658        }
1659    }
1660    impl std::convert::From<crate::generated::all::Span> for AnchorChild {
1661        fn from(value: crate::generated::all::Span) -> Self {
1662            Self::Span(value)
1663        }
1664    }
1665    impl std::convert::From<crate::generated::all::StrikeThrough> for AnchorChild {
1666        fn from(value: crate::generated::all::StrikeThrough) -> Self {
1667            Self::StrikeThrough(value)
1668        }
1669    }
1670    impl std::convert::From<crate::generated::all::Strong> for AnchorChild {
1671        fn from(value: crate::generated::all::Strong) -> Self {
1672            Self::Strong(value)
1673        }
1674    }
1675    impl std::convert::From<crate::generated::all::Style> for AnchorChild {
1676        fn from(value: crate::generated::all::Style) -> Self {
1677            Self::Style(value)
1678        }
1679    }
1680    impl std::convert::From<crate::generated::all::SubScript> for AnchorChild {
1681        fn from(value: crate::generated::all::SubScript) -> Self {
1682            Self::SubScript(value)
1683        }
1684    }
1685    impl std::convert::From<crate::generated::all::Summary> for AnchorChild {
1686        fn from(value: crate::generated::all::Summary) -> Self {
1687            Self::Summary(value)
1688        }
1689    }
1690    impl std::convert::From<crate::generated::all::SuperScript> for AnchorChild {
1691        fn from(value: crate::generated::all::SuperScript) -> Self {
1692            Self::SuperScript(value)
1693        }
1694    }
1695    impl std::convert::From<crate::generated::all::Table> for AnchorChild {
1696        fn from(value: crate::generated::all::Table) -> Self {
1697            Self::Table(value)
1698        }
1699    }
1700    impl std::convert::From<crate::generated::all::TableBody> for AnchorChild {
1701        fn from(value: crate::generated::all::TableBody) -> Self {
1702            Self::TableBody(value)
1703        }
1704    }
1705    impl std::convert::From<crate::generated::all::TableCell> for AnchorChild {
1706        fn from(value: crate::generated::all::TableCell) -> Self {
1707            Self::TableCell(value)
1708        }
1709    }
1710    impl std::convert::From<crate::generated::all::TableColumn> for AnchorChild {
1711        fn from(value: crate::generated::all::TableColumn) -> Self {
1712            Self::TableColumn(value)
1713        }
1714    }
1715    impl std::convert::From<crate::generated::all::TableColumnGroup> for AnchorChild {
1716        fn from(value: crate::generated::all::TableColumnGroup) -> Self {
1717            Self::TableColumnGroup(value)
1718        }
1719    }
1720    impl std::convert::From<crate::generated::all::TableFoot> for AnchorChild {
1721        fn from(value: crate::generated::all::TableFoot) -> Self {
1722            Self::TableFoot(value)
1723        }
1724    }
1725    impl std::convert::From<crate::generated::all::TableHead> for AnchorChild {
1726        fn from(value: crate::generated::all::TableHead) -> Self {
1727            Self::TableHead(value)
1728        }
1729    }
1730    impl std::convert::From<crate::generated::all::TableHeader> for AnchorChild {
1731        fn from(value: crate::generated::all::TableHeader) -> Self {
1732            Self::TableHeader(value)
1733        }
1734    }
1735    impl std::convert::From<crate::generated::all::TableRow> for AnchorChild {
1736        fn from(value: crate::generated::all::TableRow) -> Self {
1737            Self::TableRow(value)
1738        }
1739    }
1740    impl std::convert::From<crate::generated::all::Template> for AnchorChild {
1741        fn from(value: crate::generated::all::Template) -> Self {
1742            Self::Template(value)
1743        }
1744    }
1745    impl std::convert::From<std::borrow::Cow<'static, str>> for AnchorChild {
1746        fn from(value: std::borrow::Cow<'static, str>) -> Self {
1747            Self::Text(value)
1748        }
1749    }
1750    impl std::convert::From<&'static str> for AnchorChild {
1751        fn from(value: &'static str) -> Self {
1752            Self::Text(value.into())
1753        }
1754    }
1755    impl std::convert::From<String> for AnchorChild {
1756        fn from(value: String) -> Self {
1757            Self::Text(value.into())
1758        }
1759    }
1760    impl std::convert::From<crate::generated::all::TextArea> for AnchorChild {
1761        fn from(value: crate::generated::all::TextArea) -> Self {
1762            Self::TextArea(value)
1763        }
1764    }
1765    impl std::convert::From<crate::generated::all::TextTrack> for AnchorChild {
1766        fn from(value: crate::generated::all::TextTrack) -> Self {
1767            Self::TextTrack(value)
1768        }
1769    }
1770    impl std::convert::From<crate::generated::all::ThematicBreak> for AnchorChild {
1771        fn from(value: crate::generated::all::ThematicBreak) -> Self {
1772            Self::ThematicBreak(value)
1773        }
1774    }
1775    impl std::convert::From<crate::generated::all::Time> for AnchorChild {
1776        fn from(value: crate::generated::all::Time) -> Self {
1777            Self::Time(value)
1778        }
1779    }
1780    impl std::convert::From<crate::generated::all::Title> for AnchorChild {
1781        fn from(value: crate::generated::all::Title) -> Self {
1782            Self::Title(value)
1783        }
1784    }
1785    impl std::convert::From<crate::generated::all::Underline> for AnchorChild {
1786        fn from(value: crate::generated::all::Underline) -> Self {
1787            Self::Underline(value)
1788        }
1789    }
1790    impl std::convert::From<crate::generated::all::UnorderedList> for AnchorChild {
1791        fn from(value: crate::generated::all::UnorderedList) -> Self {
1792            Self::UnorderedList(value)
1793        }
1794    }
1795    impl std::convert::From<crate::generated::all::Variable> for AnchorChild {
1796        fn from(value: crate::generated::all::Variable) -> Self {
1797            Self::Variable(value)
1798        }
1799    }
1800    impl std::convert::From<crate::generated::all::Video> for AnchorChild {
1801        fn from(value: crate::generated::all::Video) -> Self {
1802            Self::Video(value)
1803        }
1804    }
1805    impl crate::Render for AnchorChild {
1806        fn render(
1807            &self,
1808            f: &mut std::fmt::Formatter<'_>,
1809            depth: usize,
1810        ) -> std::fmt::Result {
1811            match self {
1812                Self::Abbreviation(el) => crate::Render::render(el, f, depth + 1),
1813                Self::Address(el) => crate::Render::render(el, f, depth + 1),
1814                Self::Anchor(el) => crate::Render::render(el, f, depth + 1),
1815                Self::Article(el) => crate::Render::render(el, f, depth + 1),
1816                Self::Aside(el) => crate::Render::render(el, f, depth + 1),
1817                Self::Audio(el) => crate::Render::render(el, f, depth + 1),
1818                Self::Base(el) => crate::Render::render(el, f, depth + 1),
1819                Self::BidirectionalIsolate(el) => crate::Render::render(el, f, depth + 1),
1820                Self::BidirectionalTextOverride(el) => {
1821                    crate::Render::render(el, f, depth + 1)
1822                }
1823                Self::BlockQuote(el) => crate::Render::render(el, f, depth + 1),
1824                Self::Body(el) => crate::Render::render(el, f, depth + 1),
1825                Self::Bold(el) => crate::Render::render(el, f, depth + 1),
1826                Self::Button(el) => crate::Render::render(el, f, depth + 1),
1827                Self::Canvas(el) => crate::Render::render(el, f, depth + 1),
1828                Self::Caption(el) => crate::Render::render(el, f, depth + 1),
1829                Self::Cite(el) => crate::Render::render(el, f, depth + 1),
1830                Self::Code(el) => crate::Render::render(el, f, depth + 1),
1831                Self::Data(el) => crate::Render::render(el, f, depth + 1),
1832                Self::DataList(el) => crate::Render::render(el, f, depth + 1),
1833                Self::Definition(el) => crate::Render::render(el, f, depth + 1),
1834                Self::DeletedText(el) => crate::Render::render(el, f, depth + 1),
1835                Self::DescriptionDetails(el) => crate::Render::render(el, f, depth + 1),
1836                Self::DescriptionList(el) => crate::Render::render(el, f, depth + 1),
1837                Self::DescriptionTerm(el) => crate::Render::render(el, f, depth + 1),
1838                Self::Details(el) => crate::Render::render(el, f, depth + 1),
1839                Self::Dialog(el) => crate::Render::render(el, f, depth + 1),
1840                Self::Division(el) => crate::Render::render(el, f, depth + 1),
1841                Self::Embed(el) => crate::Render::render(el, f, depth + 1),
1842                Self::Emphasis(el) => crate::Render::render(el, f, depth + 1),
1843                Self::Fieldset(el) => crate::Render::render(el, f, depth + 1),
1844                Self::Figure(el) => crate::Render::render(el, f, depth + 1),
1845                Self::FigureCaption(el) => crate::Render::render(el, f, depth + 1),
1846                Self::Footer(el) => crate::Render::render(el, f, depth + 1),
1847                Self::Form(el) => crate::Render::render(el, f, depth + 1),
1848                Self::Head(el) => crate::Render::render(el, f, depth + 1),
1849                Self::Header(el) => crate::Render::render(el, f, depth + 1),
1850                Self::Heading1(el) => crate::Render::render(el, f, depth + 1),
1851                Self::Heading2(el) => crate::Render::render(el, f, depth + 1),
1852                Self::Heading3(el) => crate::Render::render(el, f, depth + 1),
1853                Self::Heading4(el) => crate::Render::render(el, f, depth + 1),
1854                Self::Heading5(el) => crate::Render::render(el, f, depth + 1),
1855                Self::Heading6(el) => crate::Render::render(el, f, depth + 1),
1856                Self::HeadingGroup(el) => crate::Render::render(el, f, depth + 1),
1857                Self::Html(el) => crate::Render::render(el, f, depth + 1),
1858                Self::Iframe(el) => crate::Render::render(el, f, depth + 1),
1859                Self::Image(el) => crate::Render::render(el, f, depth + 1),
1860                Self::ImageMap(el) => crate::Render::render(el, f, depth + 1),
1861                Self::ImageMapArea(el) => crate::Render::render(el, f, depth + 1),
1862                Self::Input(el) => crate::Render::render(el, f, depth + 1),
1863                Self::InsertedText(el) => crate::Render::render(el, f, depth + 1),
1864                Self::Italic(el) => crate::Render::render(el, f, depth + 1),
1865                Self::KeyboardInput(el) => crate::Render::render(el, f, depth + 1),
1866                Self::Label(el) => crate::Render::render(el, f, depth + 1),
1867                Self::Legend(el) => crate::Render::render(el, f, depth + 1),
1868                Self::LineBreak(el) => crate::Render::render(el, f, depth + 1),
1869                Self::LineBreakOpportunity(el) => crate::Render::render(el, f, depth + 1),
1870                Self::Link(el) => crate::Render::render(el, f, depth + 1),
1871                Self::ListItem(el) => crate::Render::render(el, f, depth + 1),
1872                Self::Main(el) => crate::Render::render(el, f, depth + 1),
1873                Self::MarkText(el) => crate::Render::render(el, f, depth + 1),
1874                Self::MediaSource(el) => crate::Render::render(el, f, depth + 1),
1875                Self::Menu(el) => crate::Render::render(el, f, depth + 1),
1876                Self::Meta(el) => crate::Render::render(el, f, depth + 1),
1877                Self::Meter(el) => crate::Render::render(el, f, depth + 1),
1878                Self::Navigation(el) => crate::Render::render(el, f, depth + 1),
1879                Self::NoScript(el) => crate::Render::render(el, f, depth + 1),
1880                Self::Object(el) => crate::Render::render(el, f, depth + 1),
1881                Self::Option(el) => crate::Render::render(el, f, depth + 1),
1882                Self::OptionGroup(el) => crate::Render::render(el, f, depth + 1),
1883                Self::OrderedList(el) => crate::Render::render(el, f, depth + 1),
1884                Self::Output(el) => crate::Render::render(el, f, depth + 1),
1885                Self::Paragraph(el) => crate::Render::render(el, f, depth + 1),
1886                Self::Picture(el) => crate::Render::render(el, f, depth + 1),
1887                Self::PreformattedText(el) => crate::Render::render(el, f, depth + 1),
1888                Self::Progress(el) => crate::Render::render(el, f, depth + 1),
1889                Self::Quotation(el) => crate::Render::render(el, f, depth + 1),
1890                Self::RubyAnnotation(el) => crate::Render::render(el, f, depth + 1),
1891                Self::RubyFallbackParenthesis(el) => {
1892                    crate::Render::render(el, f, depth + 1)
1893                }
1894                Self::RubyText(el) => crate::Render::render(el, f, depth + 1),
1895                Self::SampleOutput(el) => crate::Render::render(el, f, depth + 1),
1896                Self::Script(el) => crate::Render::render(el, f, depth + 1),
1897                Self::Search(el) => crate::Render::render(el, f, depth + 1),
1898                Self::Section(el) => crate::Render::render(el, f, depth + 1),
1899                Self::Select(el) => crate::Render::render(el, f, depth + 1),
1900                Self::SideComment(el) => crate::Render::render(el, f, depth + 1),
1901                Self::Slot(el) => crate::Render::render(el, f, depth + 1),
1902                Self::Span(el) => crate::Render::render(el, f, depth + 1),
1903                Self::StrikeThrough(el) => crate::Render::render(el, f, depth + 1),
1904                Self::Strong(el) => crate::Render::render(el, f, depth + 1),
1905                Self::Style(el) => crate::Render::render(el, f, depth + 1),
1906                Self::SubScript(el) => crate::Render::render(el, f, depth + 1),
1907                Self::Summary(el) => crate::Render::render(el, f, depth + 1),
1908                Self::SuperScript(el) => crate::Render::render(el, f, depth + 1),
1909                Self::Table(el) => crate::Render::render(el, f, depth + 1),
1910                Self::TableBody(el) => crate::Render::render(el, f, depth + 1),
1911                Self::TableCell(el) => crate::Render::render(el, f, depth + 1),
1912                Self::TableColumn(el) => crate::Render::render(el, f, depth + 1),
1913                Self::TableColumnGroup(el) => crate::Render::render(el, f, depth + 1),
1914                Self::TableFoot(el) => crate::Render::render(el, f, depth + 1),
1915                Self::TableHead(el) => crate::Render::render(el, f, depth + 1),
1916                Self::TableHeader(el) => crate::Render::render(el, f, depth + 1),
1917                Self::TableRow(el) => crate::Render::render(el, f, depth + 1),
1918                Self::Template(el) => crate::Render::render(el, f, depth + 1),
1919                Self::Text(el) => crate::Render::render(el, f, depth + 1),
1920                Self::TextArea(el) => crate::Render::render(el, f, depth + 1),
1921                Self::TextTrack(el) => crate::Render::render(el, f, depth + 1),
1922                Self::ThematicBreak(el) => crate::Render::render(el, f, depth + 1),
1923                Self::Time(el) => crate::Render::render(el, f, depth + 1),
1924                Self::Title(el) => crate::Render::render(el, f, depth + 1),
1925                Self::Underline(el) => crate::Render::render(el, f, depth + 1),
1926                Self::UnorderedList(el) => crate::Render::render(el, f, depth + 1),
1927                Self::Variable(el) => crate::Render::render(el, f, depth + 1),
1928                Self::Video(el) => crate::Render::render(el, f, depth + 1),
1929            }
1930        }
1931    }
1932    impl std::fmt::Debug for AnchorChild {
1933        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1934            crate::Render::render(self, f, 0)?;
1935            Ok(())
1936        }
1937    }
1938    impl std::fmt::Display for AnchorChild {
1939        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1940            match self {
1941                Self::Abbreviation(el) => write!(f, "{el}"),
1942                Self::Address(el) => write!(f, "{el}"),
1943                Self::Anchor(el) => write!(f, "{el}"),
1944                Self::Article(el) => write!(f, "{el}"),
1945                Self::Aside(el) => write!(f, "{el}"),
1946                Self::Audio(el) => write!(f, "{el}"),
1947                Self::Base(el) => write!(f, "{el}"),
1948                Self::BidirectionalIsolate(el) => write!(f, "{el}"),
1949                Self::BidirectionalTextOverride(el) => write!(f, "{el}"),
1950                Self::BlockQuote(el) => write!(f, "{el}"),
1951                Self::Body(el) => write!(f, "{el}"),
1952                Self::Bold(el) => write!(f, "{el}"),
1953                Self::Button(el) => write!(f, "{el}"),
1954                Self::Canvas(el) => write!(f, "{el}"),
1955                Self::Caption(el) => write!(f, "{el}"),
1956                Self::Cite(el) => write!(f, "{el}"),
1957                Self::Code(el) => write!(f, "{el}"),
1958                Self::Data(el) => write!(f, "{el}"),
1959                Self::DataList(el) => write!(f, "{el}"),
1960                Self::Definition(el) => write!(f, "{el}"),
1961                Self::DeletedText(el) => write!(f, "{el}"),
1962                Self::DescriptionDetails(el) => write!(f, "{el}"),
1963                Self::DescriptionList(el) => write!(f, "{el}"),
1964                Self::DescriptionTerm(el) => write!(f, "{el}"),
1965                Self::Details(el) => write!(f, "{el}"),
1966                Self::Dialog(el) => write!(f, "{el}"),
1967                Self::Division(el) => write!(f, "{el}"),
1968                Self::Embed(el) => write!(f, "{el}"),
1969                Self::Emphasis(el) => write!(f, "{el}"),
1970                Self::Fieldset(el) => write!(f, "{el}"),
1971                Self::Figure(el) => write!(f, "{el}"),
1972                Self::FigureCaption(el) => write!(f, "{el}"),
1973                Self::Footer(el) => write!(f, "{el}"),
1974                Self::Form(el) => write!(f, "{el}"),
1975                Self::Head(el) => write!(f, "{el}"),
1976                Self::Header(el) => write!(f, "{el}"),
1977                Self::Heading1(el) => write!(f, "{el}"),
1978                Self::Heading2(el) => write!(f, "{el}"),
1979                Self::Heading3(el) => write!(f, "{el}"),
1980                Self::Heading4(el) => write!(f, "{el}"),
1981                Self::Heading5(el) => write!(f, "{el}"),
1982                Self::Heading6(el) => write!(f, "{el}"),
1983                Self::HeadingGroup(el) => write!(f, "{el}"),
1984                Self::Html(el) => write!(f, "{el}"),
1985                Self::Iframe(el) => write!(f, "{el}"),
1986                Self::Image(el) => write!(f, "{el}"),
1987                Self::ImageMap(el) => write!(f, "{el}"),
1988                Self::ImageMapArea(el) => write!(f, "{el}"),
1989                Self::Input(el) => write!(f, "{el}"),
1990                Self::InsertedText(el) => write!(f, "{el}"),
1991                Self::Italic(el) => write!(f, "{el}"),
1992                Self::KeyboardInput(el) => write!(f, "{el}"),
1993                Self::Label(el) => write!(f, "{el}"),
1994                Self::Legend(el) => write!(f, "{el}"),
1995                Self::LineBreak(el) => write!(f, "{el}"),
1996                Self::LineBreakOpportunity(el) => write!(f, "{el}"),
1997                Self::Link(el) => write!(f, "{el}"),
1998                Self::ListItem(el) => write!(f, "{el}"),
1999                Self::Main(el) => write!(f, "{el}"),
2000                Self::MarkText(el) => write!(f, "{el}"),
2001                Self::MediaSource(el) => write!(f, "{el}"),
2002                Self::Menu(el) => write!(f, "{el}"),
2003                Self::Meta(el) => write!(f, "{el}"),
2004                Self::Meter(el) => write!(f, "{el}"),
2005                Self::Navigation(el) => write!(f, "{el}"),
2006                Self::NoScript(el) => write!(f, "{el}"),
2007                Self::Object(el) => write!(f, "{el}"),
2008                Self::Option(el) => write!(f, "{el}"),
2009                Self::OptionGroup(el) => write!(f, "{el}"),
2010                Self::OrderedList(el) => write!(f, "{el}"),
2011                Self::Output(el) => write!(f, "{el}"),
2012                Self::Paragraph(el) => write!(f, "{el}"),
2013                Self::Picture(el) => write!(f, "{el}"),
2014                Self::PreformattedText(el) => write!(f, "{el}"),
2015                Self::Progress(el) => write!(f, "{el}"),
2016                Self::Quotation(el) => write!(f, "{el}"),
2017                Self::RubyAnnotation(el) => write!(f, "{el}"),
2018                Self::RubyFallbackParenthesis(el) => write!(f, "{el}"),
2019                Self::RubyText(el) => write!(f, "{el}"),
2020                Self::SampleOutput(el) => write!(f, "{el}"),
2021                Self::Script(el) => write!(f, "{el}"),
2022                Self::Search(el) => write!(f, "{el}"),
2023                Self::Section(el) => write!(f, "{el}"),
2024                Self::Select(el) => write!(f, "{el}"),
2025                Self::SideComment(el) => write!(f, "{el}"),
2026                Self::Slot(el) => write!(f, "{el}"),
2027                Self::Span(el) => write!(f, "{el}"),
2028                Self::StrikeThrough(el) => write!(f, "{el}"),
2029                Self::Strong(el) => write!(f, "{el}"),
2030                Self::Style(el) => write!(f, "{el}"),
2031                Self::SubScript(el) => write!(f, "{el}"),
2032                Self::Summary(el) => write!(f, "{el}"),
2033                Self::SuperScript(el) => write!(f, "{el}"),
2034                Self::Table(el) => write!(f, "{el}"),
2035                Self::TableBody(el) => write!(f, "{el}"),
2036                Self::TableCell(el) => write!(f, "{el}"),
2037                Self::TableColumn(el) => write!(f, "{el}"),
2038                Self::TableColumnGroup(el) => write!(f, "{el}"),
2039                Self::TableFoot(el) => write!(f, "{el}"),
2040                Self::TableHead(el) => write!(f, "{el}"),
2041                Self::TableHeader(el) => write!(f, "{el}"),
2042                Self::TableRow(el) => write!(f, "{el}"),
2043                Self::Template(el) => write!(f, "{el}"),
2044                Self::Text(el) => write!(f, "{el}"),
2045                Self::TextArea(el) => write!(f, "{el}"),
2046                Self::TextTrack(el) => write!(f, "{el}"),
2047                Self::ThematicBreak(el) => write!(f, "{el}"),
2048                Self::Time(el) => write!(f, "{el}"),
2049                Self::Title(el) => write!(f, "{el}"),
2050                Self::Underline(el) => write!(f, "{el}"),
2051                Self::UnorderedList(el) => write!(f, "{el}"),
2052                Self::Variable(el) => write!(f, "{el}"),
2053                Self::Video(el) => write!(f, "{el}"),
2054            }
2055        }
2056    }
2057}
2058pub mod builder {
2059    /// A builder struct for Anchor
2060    pub struct AnchorBuilder {
2061        element: super::element::Anchor,
2062    }
2063    impl AnchorBuilder {
2064        pub(crate) fn new(element: super::element::Anchor) -> Self {
2065            Self { element }
2066        }
2067        /// Finish building the element
2068        pub fn build(&mut self) -> super::element::Anchor {
2069            self.element.clone()
2070        }
2071        /// Insert a `data-*` property
2072        pub fn data(
2073            &mut self,
2074            data_key: impl Into<std::borrow::Cow<'static, str>>,
2075            value: impl Into<std::borrow::Cow<'static, str>>,
2076        ) -> &mut AnchorBuilder {
2077            self.element.data_map_mut().insert(data_key.into(), value.into());
2078            self
2079        }
2080        /// Append a new `Abbreviation` element
2081        pub fn abbreviation<F>(&mut self, f: F) -> &mut Self
2082        where
2083            F: for<'a> FnOnce(
2084                &'a mut crate::generated::all::builders::AbbreviationBuilder,
2085            ) -> &'a mut crate::generated::all::builders::AbbreviationBuilder,
2086        {
2087            let ty: crate::generated::all::Abbreviation = Default::default();
2088            let mut ty_builder = crate::generated::all::builders::AbbreviationBuilder::new(
2089                ty,
2090            );
2091            (f)(&mut ty_builder);
2092            let ty = ty_builder.build();
2093            self.element.children_mut().push(ty.into());
2094            self
2095        }
2096        /// Append a new `Address` element
2097        pub fn address<F>(&mut self, f: F) -> &mut Self
2098        where
2099            F: for<'a> FnOnce(
2100                &'a mut crate::generated::all::builders::AddressBuilder,
2101            ) -> &'a mut crate::generated::all::builders::AddressBuilder,
2102        {
2103            let ty: crate::generated::all::Address = Default::default();
2104            let mut ty_builder = crate::generated::all::builders::AddressBuilder::new(
2105                ty,
2106            );
2107            (f)(&mut ty_builder);
2108            let ty = ty_builder.build();
2109            self.element.children_mut().push(ty.into());
2110            self
2111        }
2112        /// Append a new `Anchor` element
2113        pub fn anchor<F>(&mut self, f: F) -> &mut Self
2114        where
2115            F: for<'a> FnOnce(
2116                &'a mut crate::generated::all::builders::AnchorBuilder,
2117            ) -> &'a mut crate::generated::all::builders::AnchorBuilder,
2118        {
2119            let ty: crate::generated::all::Anchor = Default::default();
2120            let mut ty_builder = crate::generated::all::builders::AnchorBuilder::new(ty);
2121            (f)(&mut ty_builder);
2122            let ty = ty_builder.build();
2123            self.element.children_mut().push(ty.into());
2124            self
2125        }
2126        /// Append a new `Article` element
2127        pub fn article<F>(&mut self, f: F) -> &mut Self
2128        where
2129            F: for<'a> FnOnce(
2130                &'a mut crate::generated::all::builders::ArticleBuilder,
2131            ) -> &'a mut crate::generated::all::builders::ArticleBuilder,
2132        {
2133            let ty: crate::generated::all::Article = Default::default();
2134            let mut ty_builder = crate::generated::all::builders::ArticleBuilder::new(
2135                ty,
2136            );
2137            (f)(&mut ty_builder);
2138            let ty = ty_builder.build();
2139            self.element.children_mut().push(ty.into());
2140            self
2141        }
2142        /// Append a new `Aside` element
2143        pub fn aside<F>(&mut self, f: F) -> &mut Self
2144        where
2145            F: for<'a> FnOnce(
2146                &'a mut crate::generated::all::builders::AsideBuilder,
2147            ) -> &'a mut crate::generated::all::builders::AsideBuilder,
2148        {
2149            let ty: crate::generated::all::Aside = Default::default();
2150            let mut ty_builder = crate::generated::all::builders::AsideBuilder::new(ty);
2151            (f)(&mut ty_builder);
2152            let ty = ty_builder.build();
2153            self.element.children_mut().push(ty.into());
2154            self
2155        }
2156        /// Append a new `Audio` element
2157        pub fn audio<F>(&mut self, f: F) -> &mut Self
2158        where
2159            F: for<'a> FnOnce(
2160                &'a mut crate::generated::all::builders::AudioBuilder,
2161            ) -> &'a mut crate::generated::all::builders::AudioBuilder,
2162        {
2163            let ty: crate::generated::all::Audio = Default::default();
2164            let mut ty_builder = crate::generated::all::builders::AudioBuilder::new(ty);
2165            (f)(&mut ty_builder);
2166            let ty = ty_builder.build();
2167            self.element.children_mut().push(ty.into());
2168            self
2169        }
2170        /// Append a new `Base` element
2171        pub fn base<F>(&mut self, f: F) -> &mut Self
2172        where
2173            F: for<'a> FnOnce(
2174                &'a mut crate::generated::all::builders::BaseBuilder,
2175            ) -> &'a mut crate::generated::all::builders::BaseBuilder,
2176        {
2177            let ty: crate::generated::all::Base = Default::default();
2178            let mut ty_builder = crate::generated::all::builders::BaseBuilder::new(ty);
2179            (f)(&mut ty_builder);
2180            let ty = ty_builder.build();
2181            self.element.children_mut().push(ty.into());
2182            self
2183        }
2184        /// Append a new `BidirectionalIsolate` element
2185        pub fn bidirectional_isolate<F>(&mut self, f: F) -> &mut Self
2186        where
2187            F: for<'a> FnOnce(
2188                &'a mut crate::generated::all::builders::BidirectionalIsolateBuilder,
2189            ) -> &'a mut crate::generated::all::builders::BidirectionalIsolateBuilder,
2190        {
2191            let ty: crate::generated::all::BidirectionalIsolate = Default::default();
2192            let mut ty_builder = crate::generated::all::builders::BidirectionalIsolateBuilder::new(
2193                ty,
2194            );
2195            (f)(&mut ty_builder);
2196            let ty = ty_builder.build();
2197            self.element.children_mut().push(ty.into());
2198            self
2199        }
2200        /// Append a new `BidirectionalTextOverride` element
2201        pub fn bidirectional_text_override<F>(&mut self, f: F) -> &mut Self
2202        where
2203            F: for<'a> FnOnce(
2204                &'a mut crate::generated::all::builders::BidirectionalTextOverrideBuilder,
2205            ) -> &'a mut crate::generated::all::builders::BidirectionalTextOverrideBuilder,
2206        {
2207            let ty: crate::generated::all::BidirectionalTextOverride = Default::default();
2208            let mut ty_builder = crate::generated::all::builders::BidirectionalTextOverrideBuilder::new(
2209                ty,
2210            );
2211            (f)(&mut ty_builder);
2212            let ty = ty_builder.build();
2213            self.element.children_mut().push(ty.into());
2214            self
2215        }
2216        /// Append a new `BlockQuote` element
2217        pub fn block_quote<F>(&mut self, f: F) -> &mut Self
2218        where
2219            F: for<'a> FnOnce(
2220                &'a mut crate::generated::all::builders::BlockQuoteBuilder,
2221            ) -> &'a mut crate::generated::all::builders::BlockQuoteBuilder,
2222        {
2223            let ty: crate::generated::all::BlockQuote = Default::default();
2224            let mut ty_builder = crate::generated::all::builders::BlockQuoteBuilder::new(
2225                ty,
2226            );
2227            (f)(&mut ty_builder);
2228            let ty = ty_builder.build();
2229            self.element.children_mut().push(ty.into());
2230            self
2231        }
2232        /// Append a new `Body` element
2233        pub fn body<F>(&mut self, f: F) -> &mut Self
2234        where
2235            F: for<'a> FnOnce(
2236                &'a mut crate::generated::all::builders::BodyBuilder,
2237            ) -> &'a mut crate::generated::all::builders::BodyBuilder,
2238        {
2239            let ty: crate::generated::all::Body = Default::default();
2240            let mut ty_builder = crate::generated::all::builders::BodyBuilder::new(ty);
2241            (f)(&mut ty_builder);
2242            let ty = ty_builder.build();
2243            self.element.children_mut().push(ty.into());
2244            self
2245        }
2246        /// Append a new `Bold` element
2247        pub fn bold<F>(&mut self, f: F) -> &mut Self
2248        where
2249            F: for<'a> FnOnce(
2250                &'a mut crate::generated::all::builders::BoldBuilder,
2251            ) -> &'a mut crate::generated::all::builders::BoldBuilder,
2252        {
2253            let ty: crate::generated::all::Bold = Default::default();
2254            let mut ty_builder = crate::generated::all::builders::BoldBuilder::new(ty);
2255            (f)(&mut ty_builder);
2256            let ty = ty_builder.build();
2257            self.element.children_mut().push(ty.into());
2258            self
2259        }
2260        /// Append a new `Button` element
2261        pub fn button<F>(&mut self, f: F) -> &mut Self
2262        where
2263            F: for<'a> FnOnce(
2264                &'a mut crate::generated::all::builders::ButtonBuilder,
2265            ) -> &'a mut crate::generated::all::builders::ButtonBuilder,
2266        {
2267            let ty: crate::generated::all::Button = Default::default();
2268            let mut ty_builder = crate::generated::all::builders::ButtonBuilder::new(ty);
2269            (f)(&mut ty_builder);
2270            let ty = ty_builder.build();
2271            self.element.children_mut().push(ty.into());
2272            self
2273        }
2274        /// Append a new `Canvas` element
2275        pub fn canvas<F>(&mut self, f: F) -> &mut Self
2276        where
2277            F: for<'a> FnOnce(
2278                &'a mut crate::generated::all::builders::CanvasBuilder,
2279            ) -> &'a mut crate::generated::all::builders::CanvasBuilder,
2280        {
2281            let ty: crate::generated::all::Canvas = Default::default();
2282            let mut ty_builder = crate::generated::all::builders::CanvasBuilder::new(ty);
2283            (f)(&mut ty_builder);
2284            let ty = ty_builder.build();
2285            self.element.children_mut().push(ty.into());
2286            self
2287        }
2288        /// Append a new `Caption` element
2289        pub fn caption<F>(&mut self, f: F) -> &mut Self
2290        where
2291            F: for<'a> FnOnce(
2292                &'a mut crate::generated::all::builders::CaptionBuilder,
2293            ) -> &'a mut crate::generated::all::builders::CaptionBuilder,
2294        {
2295            let ty: crate::generated::all::Caption = Default::default();
2296            let mut ty_builder = crate::generated::all::builders::CaptionBuilder::new(
2297                ty,
2298            );
2299            (f)(&mut ty_builder);
2300            let ty = ty_builder.build();
2301            self.element.children_mut().push(ty.into());
2302            self
2303        }
2304        /// Append a new `Cite` element
2305        pub fn cite<F>(&mut self, f: F) -> &mut Self
2306        where
2307            F: for<'a> FnOnce(
2308                &'a mut crate::generated::all::builders::CiteBuilder,
2309            ) -> &'a mut crate::generated::all::builders::CiteBuilder,
2310        {
2311            let ty: crate::generated::all::Cite = Default::default();
2312            let mut ty_builder = crate::generated::all::builders::CiteBuilder::new(ty);
2313            (f)(&mut ty_builder);
2314            let ty = ty_builder.build();
2315            self.element.children_mut().push(ty.into());
2316            self
2317        }
2318        /// Append a new `Code` element
2319        pub fn code<F>(&mut self, f: F) -> &mut Self
2320        where
2321            F: for<'a> FnOnce(
2322                &'a mut crate::generated::all::builders::CodeBuilder,
2323            ) -> &'a mut crate::generated::all::builders::CodeBuilder,
2324        {
2325            let ty: crate::generated::all::Code = Default::default();
2326            let mut ty_builder = crate::generated::all::builders::CodeBuilder::new(ty);
2327            (f)(&mut ty_builder);
2328            let ty = ty_builder.build();
2329            self.element.children_mut().push(ty.into());
2330            self
2331        }
2332        /// Append a new `Data` element
2333        pub fn data_el<F>(&mut self, f: F) -> &mut Self
2334        where
2335            F: for<'a> FnOnce(
2336                &'a mut crate::generated::all::builders::DataBuilder,
2337            ) -> &'a mut crate::generated::all::builders::DataBuilder,
2338        {
2339            let ty: crate::generated::all::Data = Default::default();
2340            let mut ty_builder = crate::generated::all::builders::DataBuilder::new(ty);
2341            (f)(&mut ty_builder);
2342            let ty = ty_builder.build();
2343            self.element.children_mut().push(ty.into());
2344            self
2345        }
2346        /// Append a new `DataList` element
2347        pub fn data_list<F>(&mut self, f: F) -> &mut Self
2348        where
2349            F: for<'a> FnOnce(
2350                &'a mut crate::generated::all::builders::DataListBuilder,
2351            ) -> &'a mut crate::generated::all::builders::DataListBuilder,
2352        {
2353            let ty: crate::generated::all::DataList = Default::default();
2354            let mut ty_builder = crate::generated::all::builders::DataListBuilder::new(
2355                ty,
2356            );
2357            (f)(&mut ty_builder);
2358            let ty = ty_builder.build();
2359            self.element.children_mut().push(ty.into());
2360            self
2361        }
2362        /// Append a new `Definition` element
2363        pub fn definition<F>(&mut self, f: F) -> &mut Self
2364        where
2365            F: for<'a> FnOnce(
2366                &'a mut crate::generated::all::builders::DefinitionBuilder,
2367            ) -> &'a mut crate::generated::all::builders::DefinitionBuilder,
2368        {
2369            let ty: crate::generated::all::Definition = Default::default();
2370            let mut ty_builder = crate::generated::all::builders::DefinitionBuilder::new(
2371                ty,
2372            );
2373            (f)(&mut ty_builder);
2374            let ty = ty_builder.build();
2375            self.element.children_mut().push(ty.into());
2376            self
2377        }
2378        /// Append a new `DeletedText` element
2379        pub fn deleted_text<F>(&mut self, f: F) -> &mut Self
2380        where
2381            F: for<'a> FnOnce(
2382                &'a mut crate::generated::all::builders::DeletedTextBuilder,
2383            ) -> &'a mut crate::generated::all::builders::DeletedTextBuilder,
2384        {
2385            let ty: crate::generated::all::DeletedText = Default::default();
2386            let mut ty_builder = crate::generated::all::builders::DeletedTextBuilder::new(
2387                ty,
2388            );
2389            (f)(&mut ty_builder);
2390            let ty = ty_builder.build();
2391            self.element.children_mut().push(ty.into());
2392            self
2393        }
2394        /// Append a new `DescriptionDetails` element
2395        pub fn description_details<F>(&mut self, f: F) -> &mut Self
2396        where
2397            F: for<'a> FnOnce(
2398                &'a mut crate::generated::all::builders::DescriptionDetailsBuilder,
2399            ) -> &'a mut crate::generated::all::builders::DescriptionDetailsBuilder,
2400        {
2401            let ty: crate::generated::all::DescriptionDetails = Default::default();
2402            let mut ty_builder = crate::generated::all::builders::DescriptionDetailsBuilder::new(
2403                ty,
2404            );
2405            (f)(&mut ty_builder);
2406            let ty = ty_builder.build();
2407            self.element.children_mut().push(ty.into());
2408            self
2409        }
2410        /// Append a new `DescriptionList` element
2411        pub fn description_list<F>(&mut self, f: F) -> &mut Self
2412        where
2413            F: for<'a> FnOnce(
2414                &'a mut crate::generated::all::builders::DescriptionListBuilder,
2415            ) -> &'a mut crate::generated::all::builders::DescriptionListBuilder,
2416        {
2417            let ty: crate::generated::all::DescriptionList = Default::default();
2418            let mut ty_builder = crate::generated::all::builders::DescriptionListBuilder::new(
2419                ty,
2420            );
2421            (f)(&mut ty_builder);
2422            let ty = ty_builder.build();
2423            self.element.children_mut().push(ty.into());
2424            self
2425        }
2426        /// Append a new `DescriptionTerm` element
2427        pub fn description_term<F>(&mut self, f: F) -> &mut Self
2428        where
2429            F: for<'a> FnOnce(
2430                &'a mut crate::generated::all::builders::DescriptionTermBuilder,
2431            ) -> &'a mut crate::generated::all::builders::DescriptionTermBuilder,
2432        {
2433            let ty: crate::generated::all::DescriptionTerm = Default::default();
2434            let mut ty_builder = crate::generated::all::builders::DescriptionTermBuilder::new(
2435                ty,
2436            );
2437            (f)(&mut ty_builder);
2438            let ty = ty_builder.build();
2439            self.element.children_mut().push(ty.into());
2440            self
2441        }
2442        /// Append a new `Details` element
2443        pub fn details<F>(&mut self, f: F) -> &mut Self
2444        where
2445            F: for<'a> FnOnce(
2446                &'a mut crate::generated::all::builders::DetailsBuilder,
2447            ) -> &'a mut crate::generated::all::builders::DetailsBuilder,
2448        {
2449            let ty: crate::generated::all::Details = Default::default();
2450            let mut ty_builder = crate::generated::all::builders::DetailsBuilder::new(
2451                ty,
2452            );
2453            (f)(&mut ty_builder);
2454            let ty = ty_builder.build();
2455            self.element.children_mut().push(ty.into());
2456            self
2457        }
2458        /// Append a new `Dialog` element
2459        pub fn dialog<F>(&mut self, f: F) -> &mut Self
2460        where
2461            F: for<'a> FnOnce(
2462                &'a mut crate::generated::all::builders::DialogBuilder,
2463            ) -> &'a mut crate::generated::all::builders::DialogBuilder,
2464        {
2465            let ty: crate::generated::all::Dialog = Default::default();
2466            let mut ty_builder = crate::generated::all::builders::DialogBuilder::new(ty);
2467            (f)(&mut ty_builder);
2468            let ty = ty_builder.build();
2469            self.element.children_mut().push(ty.into());
2470            self
2471        }
2472        /// Append a new `Division` element
2473        pub fn division<F>(&mut self, f: F) -> &mut Self
2474        where
2475            F: for<'a> FnOnce(
2476                &'a mut crate::generated::all::builders::DivisionBuilder,
2477            ) -> &'a mut crate::generated::all::builders::DivisionBuilder,
2478        {
2479            let ty: crate::generated::all::Division = Default::default();
2480            let mut ty_builder = crate::generated::all::builders::DivisionBuilder::new(
2481                ty,
2482            );
2483            (f)(&mut ty_builder);
2484            let ty = ty_builder.build();
2485            self.element.children_mut().push(ty.into());
2486            self
2487        }
2488        /// Append a new `Embed` element
2489        pub fn embed<F>(&mut self, f: F) -> &mut Self
2490        where
2491            F: for<'a> FnOnce(
2492                &'a mut crate::generated::all::builders::EmbedBuilder,
2493            ) -> &'a mut crate::generated::all::builders::EmbedBuilder,
2494        {
2495            let ty: crate::generated::all::Embed = Default::default();
2496            let mut ty_builder = crate::generated::all::builders::EmbedBuilder::new(ty);
2497            (f)(&mut ty_builder);
2498            let ty = ty_builder.build();
2499            self.element.children_mut().push(ty.into());
2500            self
2501        }
2502        /// Append a new `Emphasis` element
2503        pub fn emphasis<F>(&mut self, f: F) -> &mut Self
2504        where
2505            F: for<'a> FnOnce(
2506                &'a mut crate::generated::all::builders::EmphasisBuilder,
2507            ) -> &'a mut crate::generated::all::builders::EmphasisBuilder,
2508        {
2509            let ty: crate::generated::all::Emphasis = Default::default();
2510            let mut ty_builder = crate::generated::all::builders::EmphasisBuilder::new(
2511                ty,
2512            );
2513            (f)(&mut ty_builder);
2514            let ty = ty_builder.build();
2515            self.element.children_mut().push(ty.into());
2516            self
2517        }
2518        /// Append a new `Fieldset` element
2519        pub fn fieldset<F>(&mut self, f: F) -> &mut Self
2520        where
2521            F: for<'a> FnOnce(
2522                &'a mut crate::generated::all::builders::FieldsetBuilder,
2523            ) -> &'a mut crate::generated::all::builders::FieldsetBuilder,
2524        {
2525            let ty: crate::generated::all::Fieldset = Default::default();
2526            let mut ty_builder = crate::generated::all::builders::FieldsetBuilder::new(
2527                ty,
2528            );
2529            (f)(&mut ty_builder);
2530            let ty = ty_builder.build();
2531            self.element.children_mut().push(ty.into());
2532            self
2533        }
2534        /// Append a new `Figure` element
2535        pub fn figure<F>(&mut self, f: F) -> &mut Self
2536        where
2537            F: for<'a> FnOnce(
2538                &'a mut crate::generated::all::builders::FigureBuilder,
2539            ) -> &'a mut crate::generated::all::builders::FigureBuilder,
2540        {
2541            let ty: crate::generated::all::Figure = Default::default();
2542            let mut ty_builder = crate::generated::all::builders::FigureBuilder::new(ty);
2543            (f)(&mut ty_builder);
2544            let ty = ty_builder.build();
2545            self.element.children_mut().push(ty.into());
2546            self
2547        }
2548        /// Append a new `FigureCaption` element
2549        pub fn figure_caption<F>(&mut self, f: F) -> &mut Self
2550        where
2551            F: for<'a> FnOnce(
2552                &'a mut crate::generated::all::builders::FigureCaptionBuilder,
2553            ) -> &'a mut crate::generated::all::builders::FigureCaptionBuilder,
2554        {
2555            let ty: crate::generated::all::FigureCaption = Default::default();
2556            let mut ty_builder = crate::generated::all::builders::FigureCaptionBuilder::new(
2557                ty,
2558            );
2559            (f)(&mut ty_builder);
2560            let ty = ty_builder.build();
2561            self.element.children_mut().push(ty.into());
2562            self
2563        }
2564        /// Append a new `Footer` element
2565        pub fn footer<F>(&mut self, f: F) -> &mut Self
2566        where
2567            F: for<'a> FnOnce(
2568                &'a mut crate::generated::all::builders::FooterBuilder,
2569            ) -> &'a mut crate::generated::all::builders::FooterBuilder,
2570        {
2571            let ty: crate::generated::all::Footer = Default::default();
2572            let mut ty_builder = crate::generated::all::builders::FooterBuilder::new(ty);
2573            (f)(&mut ty_builder);
2574            let ty = ty_builder.build();
2575            self.element.children_mut().push(ty.into());
2576            self
2577        }
2578        /// Append a new `Form` element
2579        pub fn form<F>(&mut self, f: F) -> &mut Self
2580        where
2581            F: for<'a> FnOnce(
2582                &'a mut crate::generated::all::builders::FormBuilder,
2583            ) -> &'a mut crate::generated::all::builders::FormBuilder,
2584        {
2585            let ty: crate::generated::all::Form = Default::default();
2586            let mut ty_builder = crate::generated::all::builders::FormBuilder::new(ty);
2587            (f)(&mut ty_builder);
2588            let ty = ty_builder.build();
2589            self.element.children_mut().push(ty.into());
2590            self
2591        }
2592        /// Append a new `Head` element
2593        pub fn head<F>(&mut self, f: F) -> &mut Self
2594        where
2595            F: for<'a> FnOnce(
2596                &'a mut crate::generated::all::builders::HeadBuilder,
2597            ) -> &'a mut crate::generated::all::builders::HeadBuilder,
2598        {
2599            let ty: crate::generated::all::Head = Default::default();
2600            let mut ty_builder = crate::generated::all::builders::HeadBuilder::new(ty);
2601            (f)(&mut ty_builder);
2602            let ty = ty_builder.build();
2603            self.element.children_mut().push(ty.into());
2604            self
2605        }
2606        /// Append a new `Header` element
2607        pub fn header<F>(&mut self, f: F) -> &mut Self
2608        where
2609            F: for<'a> FnOnce(
2610                &'a mut crate::generated::all::builders::HeaderBuilder,
2611            ) -> &'a mut crate::generated::all::builders::HeaderBuilder,
2612        {
2613            let ty: crate::generated::all::Header = Default::default();
2614            let mut ty_builder = crate::generated::all::builders::HeaderBuilder::new(ty);
2615            (f)(&mut ty_builder);
2616            let ty = ty_builder.build();
2617            self.element.children_mut().push(ty.into());
2618            self
2619        }
2620        /// Append a new `Heading1` element
2621        pub fn heading_1<F>(&mut self, f: F) -> &mut Self
2622        where
2623            F: for<'a> FnOnce(
2624                &'a mut crate::generated::all::builders::Heading1Builder,
2625            ) -> &'a mut crate::generated::all::builders::Heading1Builder,
2626        {
2627            let ty: crate::generated::all::Heading1 = Default::default();
2628            let mut ty_builder = crate::generated::all::builders::Heading1Builder::new(
2629                ty,
2630            );
2631            (f)(&mut ty_builder);
2632            let ty = ty_builder.build();
2633            self.element.children_mut().push(ty.into());
2634            self
2635        }
2636        /// Append a new `Heading2` element
2637        pub fn heading_2<F>(&mut self, f: F) -> &mut Self
2638        where
2639            F: for<'a> FnOnce(
2640                &'a mut crate::generated::all::builders::Heading2Builder,
2641            ) -> &'a mut crate::generated::all::builders::Heading2Builder,
2642        {
2643            let ty: crate::generated::all::Heading2 = Default::default();
2644            let mut ty_builder = crate::generated::all::builders::Heading2Builder::new(
2645                ty,
2646            );
2647            (f)(&mut ty_builder);
2648            let ty = ty_builder.build();
2649            self.element.children_mut().push(ty.into());
2650            self
2651        }
2652        /// Append a new `Heading3` element
2653        pub fn heading_3<F>(&mut self, f: F) -> &mut Self
2654        where
2655            F: for<'a> FnOnce(
2656                &'a mut crate::generated::all::builders::Heading3Builder,
2657            ) -> &'a mut crate::generated::all::builders::Heading3Builder,
2658        {
2659            let ty: crate::generated::all::Heading3 = Default::default();
2660            let mut ty_builder = crate::generated::all::builders::Heading3Builder::new(
2661                ty,
2662            );
2663            (f)(&mut ty_builder);
2664            let ty = ty_builder.build();
2665            self.element.children_mut().push(ty.into());
2666            self
2667        }
2668        /// Append a new `Heading4` element
2669        pub fn heading_4<F>(&mut self, f: F) -> &mut Self
2670        where
2671            F: for<'a> FnOnce(
2672                &'a mut crate::generated::all::builders::Heading4Builder,
2673            ) -> &'a mut crate::generated::all::builders::Heading4Builder,
2674        {
2675            let ty: crate::generated::all::Heading4 = Default::default();
2676            let mut ty_builder = crate::generated::all::builders::Heading4Builder::new(
2677                ty,
2678            );
2679            (f)(&mut ty_builder);
2680            let ty = ty_builder.build();
2681            self.element.children_mut().push(ty.into());
2682            self
2683        }
2684        /// Append a new `Heading5` element
2685        pub fn heading_5<F>(&mut self, f: F) -> &mut Self
2686        where
2687            F: for<'a> FnOnce(
2688                &'a mut crate::generated::all::builders::Heading5Builder,
2689            ) -> &'a mut crate::generated::all::builders::Heading5Builder,
2690        {
2691            let ty: crate::generated::all::Heading5 = Default::default();
2692            let mut ty_builder = crate::generated::all::builders::Heading5Builder::new(
2693                ty,
2694            );
2695            (f)(&mut ty_builder);
2696            let ty = ty_builder.build();
2697            self.element.children_mut().push(ty.into());
2698            self
2699        }
2700        /// Append a new `Heading6` element
2701        pub fn heading_6<F>(&mut self, f: F) -> &mut Self
2702        where
2703            F: for<'a> FnOnce(
2704                &'a mut crate::generated::all::builders::Heading6Builder,
2705            ) -> &'a mut crate::generated::all::builders::Heading6Builder,
2706        {
2707            let ty: crate::generated::all::Heading6 = Default::default();
2708            let mut ty_builder = crate::generated::all::builders::Heading6Builder::new(
2709                ty,
2710            );
2711            (f)(&mut ty_builder);
2712            let ty = ty_builder.build();
2713            self.element.children_mut().push(ty.into());
2714            self
2715        }
2716        /// Append a new `HeadingGroup` element
2717        pub fn heading_group<F>(&mut self, f: F) -> &mut Self
2718        where
2719            F: for<'a> FnOnce(
2720                &'a mut crate::generated::all::builders::HeadingGroupBuilder,
2721            ) -> &'a mut crate::generated::all::builders::HeadingGroupBuilder,
2722        {
2723            let ty: crate::generated::all::HeadingGroup = Default::default();
2724            let mut ty_builder = crate::generated::all::builders::HeadingGroupBuilder::new(
2725                ty,
2726            );
2727            (f)(&mut ty_builder);
2728            let ty = ty_builder.build();
2729            self.element.children_mut().push(ty.into());
2730            self
2731        }
2732        /// Append a new `Html` element
2733        pub fn html<F>(&mut self, f: F) -> &mut Self
2734        where
2735            F: for<'a> FnOnce(
2736                &'a mut crate::generated::all::builders::HtmlBuilder,
2737            ) -> &'a mut crate::generated::all::builders::HtmlBuilder,
2738        {
2739            let ty: crate::generated::all::Html = Default::default();
2740            let mut ty_builder = crate::generated::all::builders::HtmlBuilder::new(ty);
2741            (f)(&mut ty_builder);
2742            let ty = ty_builder.build();
2743            self.element.children_mut().push(ty.into());
2744            self
2745        }
2746        /// Append a new `Iframe` element
2747        pub fn iframe<F>(&mut self, f: F) -> &mut Self
2748        where
2749            F: for<'a> FnOnce(
2750                &'a mut crate::generated::all::builders::IframeBuilder,
2751            ) -> &'a mut crate::generated::all::builders::IframeBuilder,
2752        {
2753            let ty: crate::generated::all::Iframe = Default::default();
2754            let mut ty_builder = crate::generated::all::builders::IframeBuilder::new(ty);
2755            (f)(&mut ty_builder);
2756            let ty = ty_builder.build();
2757            self.element.children_mut().push(ty.into());
2758            self
2759        }
2760        /// Append a new `Image` element
2761        pub fn image<F>(&mut self, f: F) -> &mut Self
2762        where
2763            F: for<'a> FnOnce(
2764                &'a mut crate::generated::all::builders::ImageBuilder,
2765            ) -> &'a mut crate::generated::all::builders::ImageBuilder,
2766        {
2767            let ty: crate::generated::all::Image = Default::default();
2768            let mut ty_builder = crate::generated::all::builders::ImageBuilder::new(ty);
2769            (f)(&mut ty_builder);
2770            let ty = ty_builder.build();
2771            self.element.children_mut().push(ty.into());
2772            self
2773        }
2774        /// Append a new `ImageMap` element
2775        pub fn image_map<F>(&mut self, f: F) -> &mut Self
2776        where
2777            F: for<'a> FnOnce(
2778                &'a mut crate::generated::all::builders::ImageMapBuilder,
2779            ) -> &'a mut crate::generated::all::builders::ImageMapBuilder,
2780        {
2781            let ty: crate::generated::all::ImageMap = Default::default();
2782            let mut ty_builder = crate::generated::all::builders::ImageMapBuilder::new(
2783                ty,
2784            );
2785            (f)(&mut ty_builder);
2786            let ty = ty_builder.build();
2787            self.element.children_mut().push(ty.into());
2788            self
2789        }
2790        /// Append a new `ImageMapArea` element
2791        pub fn image_map_area<F>(&mut self, f: F) -> &mut Self
2792        where
2793            F: for<'a> FnOnce(
2794                &'a mut crate::generated::all::builders::ImageMapAreaBuilder,
2795            ) -> &'a mut crate::generated::all::builders::ImageMapAreaBuilder,
2796        {
2797            let ty: crate::generated::all::ImageMapArea = Default::default();
2798            let mut ty_builder = crate::generated::all::builders::ImageMapAreaBuilder::new(
2799                ty,
2800            );
2801            (f)(&mut ty_builder);
2802            let ty = ty_builder.build();
2803            self.element.children_mut().push(ty.into());
2804            self
2805        }
2806        /// Append a new `Input` element
2807        pub fn input<F>(&mut self, f: F) -> &mut Self
2808        where
2809            F: for<'a> FnOnce(
2810                &'a mut crate::generated::all::builders::InputBuilder,
2811            ) -> &'a mut crate::generated::all::builders::InputBuilder,
2812        {
2813            let ty: crate::generated::all::Input = Default::default();
2814            let mut ty_builder = crate::generated::all::builders::InputBuilder::new(ty);
2815            (f)(&mut ty_builder);
2816            let ty = ty_builder.build();
2817            self.element.children_mut().push(ty.into());
2818            self
2819        }
2820        /// Append a new `InsertedText` element
2821        pub fn inserted_text<F>(&mut self, f: F) -> &mut Self
2822        where
2823            F: for<'a> FnOnce(
2824                &'a mut crate::generated::all::builders::InsertedTextBuilder,
2825            ) -> &'a mut crate::generated::all::builders::InsertedTextBuilder,
2826        {
2827            let ty: crate::generated::all::InsertedText = Default::default();
2828            let mut ty_builder = crate::generated::all::builders::InsertedTextBuilder::new(
2829                ty,
2830            );
2831            (f)(&mut ty_builder);
2832            let ty = ty_builder.build();
2833            self.element.children_mut().push(ty.into());
2834            self
2835        }
2836        /// Append a new `Italic` element
2837        pub fn italic<F>(&mut self, f: F) -> &mut Self
2838        where
2839            F: for<'a> FnOnce(
2840                &'a mut crate::generated::all::builders::ItalicBuilder,
2841            ) -> &'a mut crate::generated::all::builders::ItalicBuilder,
2842        {
2843            let ty: crate::generated::all::Italic = Default::default();
2844            let mut ty_builder = crate::generated::all::builders::ItalicBuilder::new(ty);
2845            (f)(&mut ty_builder);
2846            let ty = ty_builder.build();
2847            self.element.children_mut().push(ty.into());
2848            self
2849        }
2850        /// Append a new `KeyboardInput` element
2851        pub fn keyboard_input<F>(&mut self, f: F) -> &mut Self
2852        where
2853            F: for<'a> FnOnce(
2854                &'a mut crate::generated::all::builders::KeyboardInputBuilder,
2855            ) -> &'a mut crate::generated::all::builders::KeyboardInputBuilder,
2856        {
2857            let ty: crate::generated::all::KeyboardInput = Default::default();
2858            let mut ty_builder = crate::generated::all::builders::KeyboardInputBuilder::new(
2859                ty,
2860            );
2861            (f)(&mut ty_builder);
2862            let ty = ty_builder.build();
2863            self.element.children_mut().push(ty.into());
2864            self
2865        }
2866        /// Append a new `Label` element
2867        pub fn label<F>(&mut self, f: F) -> &mut Self
2868        where
2869            F: for<'a> FnOnce(
2870                &'a mut crate::generated::all::builders::LabelBuilder,
2871            ) -> &'a mut crate::generated::all::builders::LabelBuilder,
2872        {
2873            let ty: crate::generated::all::Label = Default::default();
2874            let mut ty_builder = crate::generated::all::builders::LabelBuilder::new(ty);
2875            (f)(&mut ty_builder);
2876            let ty = ty_builder.build();
2877            self.element.children_mut().push(ty.into());
2878            self
2879        }
2880        /// Append a new `Legend` element
2881        pub fn legend<F>(&mut self, f: F) -> &mut Self
2882        where
2883            F: for<'a> FnOnce(
2884                &'a mut crate::generated::all::builders::LegendBuilder,
2885            ) -> &'a mut crate::generated::all::builders::LegendBuilder,
2886        {
2887            let ty: crate::generated::all::Legend = Default::default();
2888            let mut ty_builder = crate::generated::all::builders::LegendBuilder::new(ty);
2889            (f)(&mut ty_builder);
2890            let ty = ty_builder.build();
2891            self.element.children_mut().push(ty.into());
2892            self
2893        }
2894        /// Append a new `LineBreak` element
2895        pub fn line_break<F>(&mut self, f: F) -> &mut Self
2896        where
2897            F: for<'a> FnOnce(
2898                &'a mut crate::generated::all::builders::LineBreakBuilder,
2899            ) -> &'a mut crate::generated::all::builders::LineBreakBuilder,
2900        {
2901            let ty: crate::generated::all::LineBreak = Default::default();
2902            let mut ty_builder = crate::generated::all::builders::LineBreakBuilder::new(
2903                ty,
2904            );
2905            (f)(&mut ty_builder);
2906            let ty = ty_builder.build();
2907            self.element.children_mut().push(ty.into());
2908            self
2909        }
2910        /// Append a new `LineBreakOpportunity` element
2911        pub fn line_break_opportunity<F>(&mut self, f: F) -> &mut Self
2912        where
2913            F: for<'a> FnOnce(
2914                &'a mut crate::generated::all::builders::LineBreakOpportunityBuilder,
2915            ) -> &'a mut crate::generated::all::builders::LineBreakOpportunityBuilder,
2916        {
2917            let ty: crate::generated::all::LineBreakOpportunity = Default::default();
2918            let mut ty_builder = crate::generated::all::builders::LineBreakOpportunityBuilder::new(
2919                ty,
2920            );
2921            (f)(&mut ty_builder);
2922            let ty = ty_builder.build();
2923            self.element.children_mut().push(ty.into());
2924            self
2925        }
2926        /// Append a new `Link` element
2927        pub fn link<F>(&mut self, f: F) -> &mut Self
2928        where
2929            F: for<'a> FnOnce(
2930                &'a mut crate::generated::all::builders::LinkBuilder,
2931            ) -> &'a mut crate::generated::all::builders::LinkBuilder,
2932        {
2933            let ty: crate::generated::all::Link = Default::default();
2934            let mut ty_builder = crate::generated::all::builders::LinkBuilder::new(ty);
2935            (f)(&mut ty_builder);
2936            let ty = ty_builder.build();
2937            self.element.children_mut().push(ty.into());
2938            self
2939        }
2940        /// Append a new `ListItem` element
2941        pub fn list_item<F>(&mut self, f: F) -> &mut Self
2942        where
2943            F: for<'a> FnOnce(
2944                &'a mut crate::generated::all::builders::ListItemBuilder,
2945            ) -> &'a mut crate::generated::all::builders::ListItemBuilder,
2946        {
2947            let ty: crate::generated::all::ListItem = Default::default();
2948            let mut ty_builder = crate::generated::all::builders::ListItemBuilder::new(
2949                ty,
2950            );
2951            (f)(&mut ty_builder);
2952            let ty = ty_builder.build();
2953            self.element.children_mut().push(ty.into());
2954            self
2955        }
2956        /// Append a new `Main` element
2957        pub fn main<F>(&mut self, f: F) -> &mut Self
2958        where
2959            F: for<'a> FnOnce(
2960                &'a mut crate::generated::all::builders::MainBuilder,
2961            ) -> &'a mut crate::generated::all::builders::MainBuilder,
2962        {
2963            let ty: crate::generated::all::Main = Default::default();
2964            let mut ty_builder = crate::generated::all::builders::MainBuilder::new(ty);
2965            (f)(&mut ty_builder);
2966            let ty = ty_builder.build();
2967            self.element.children_mut().push(ty.into());
2968            self
2969        }
2970        /// Append a new `MarkText` element
2971        pub fn mark_text<F>(&mut self, f: F) -> &mut Self
2972        where
2973            F: for<'a> FnOnce(
2974                &'a mut crate::generated::all::builders::MarkTextBuilder,
2975            ) -> &'a mut crate::generated::all::builders::MarkTextBuilder,
2976        {
2977            let ty: crate::generated::all::MarkText = Default::default();
2978            let mut ty_builder = crate::generated::all::builders::MarkTextBuilder::new(
2979                ty,
2980            );
2981            (f)(&mut ty_builder);
2982            let ty = ty_builder.build();
2983            self.element.children_mut().push(ty.into());
2984            self
2985        }
2986        /// Append a new `MediaSource` element
2987        pub fn media_source<F>(&mut self, f: F) -> &mut Self
2988        where
2989            F: for<'a> FnOnce(
2990                &'a mut crate::generated::all::builders::MediaSourceBuilder,
2991            ) -> &'a mut crate::generated::all::builders::MediaSourceBuilder,
2992        {
2993            let ty: crate::generated::all::MediaSource = Default::default();
2994            let mut ty_builder = crate::generated::all::builders::MediaSourceBuilder::new(
2995                ty,
2996            );
2997            (f)(&mut ty_builder);
2998            let ty = ty_builder.build();
2999            self.element.children_mut().push(ty.into());
3000            self
3001        }
3002        /// Append a new `Menu` element
3003        pub fn menu<F>(&mut self, f: F) -> &mut Self
3004        where
3005            F: for<'a> FnOnce(
3006                &'a mut crate::generated::all::builders::MenuBuilder,
3007            ) -> &'a mut crate::generated::all::builders::MenuBuilder,
3008        {
3009            let ty: crate::generated::all::Menu = Default::default();
3010            let mut ty_builder = crate::generated::all::builders::MenuBuilder::new(ty);
3011            (f)(&mut ty_builder);
3012            let ty = ty_builder.build();
3013            self.element.children_mut().push(ty.into());
3014            self
3015        }
3016        /// Append a new `Meta` element
3017        pub fn meta<F>(&mut self, f: F) -> &mut Self
3018        where
3019            F: for<'a> FnOnce(
3020                &'a mut crate::generated::all::builders::MetaBuilder,
3021            ) -> &'a mut crate::generated::all::builders::MetaBuilder,
3022        {
3023            let ty: crate::generated::all::Meta = Default::default();
3024            let mut ty_builder = crate::generated::all::builders::MetaBuilder::new(ty);
3025            (f)(&mut ty_builder);
3026            let ty = ty_builder.build();
3027            self.element.children_mut().push(ty.into());
3028            self
3029        }
3030        /// Append a new `Meter` element
3031        pub fn meter<F>(&mut self, f: F) -> &mut Self
3032        where
3033            F: for<'a> FnOnce(
3034                &'a mut crate::generated::all::builders::MeterBuilder,
3035            ) -> &'a mut crate::generated::all::builders::MeterBuilder,
3036        {
3037            let ty: crate::generated::all::Meter = Default::default();
3038            let mut ty_builder = crate::generated::all::builders::MeterBuilder::new(ty);
3039            (f)(&mut ty_builder);
3040            let ty = ty_builder.build();
3041            self.element.children_mut().push(ty.into());
3042            self
3043        }
3044        /// Append a new `Navigation` element
3045        pub fn navigation<F>(&mut self, f: F) -> &mut Self
3046        where
3047            F: for<'a> FnOnce(
3048                &'a mut crate::generated::all::builders::NavigationBuilder,
3049            ) -> &'a mut crate::generated::all::builders::NavigationBuilder,
3050        {
3051            let ty: crate::generated::all::Navigation = Default::default();
3052            let mut ty_builder = crate::generated::all::builders::NavigationBuilder::new(
3053                ty,
3054            );
3055            (f)(&mut ty_builder);
3056            let ty = ty_builder.build();
3057            self.element.children_mut().push(ty.into());
3058            self
3059        }
3060        /// Append a new `NoScript` element
3061        pub fn no_script<F>(&mut self, f: F) -> &mut Self
3062        where
3063            F: for<'a> FnOnce(
3064                &'a mut crate::generated::all::builders::NoScriptBuilder,
3065            ) -> &'a mut crate::generated::all::builders::NoScriptBuilder,
3066        {
3067            let ty: crate::generated::all::NoScript = Default::default();
3068            let mut ty_builder = crate::generated::all::builders::NoScriptBuilder::new(
3069                ty,
3070            );
3071            (f)(&mut ty_builder);
3072            let ty = ty_builder.build();
3073            self.element.children_mut().push(ty.into());
3074            self
3075        }
3076        /// Append a new `Object` element
3077        pub fn object<F>(&mut self, f: F) -> &mut Self
3078        where
3079            F: for<'a> FnOnce(
3080                &'a mut crate::generated::all::builders::ObjectBuilder,
3081            ) -> &'a mut crate::generated::all::builders::ObjectBuilder,
3082        {
3083            let ty: crate::generated::all::Object = Default::default();
3084            let mut ty_builder = crate::generated::all::builders::ObjectBuilder::new(ty);
3085            (f)(&mut ty_builder);
3086            let ty = ty_builder.build();
3087            self.element.children_mut().push(ty.into());
3088            self
3089        }
3090        /// Append a new `Option` element
3091        pub fn option<F>(&mut self, f: F) -> &mut Self
3092        where
3093            F: for<'a> FnOnce(
3094                &'a mut crate::generated::all::builders::OptionBuilder,
3095            ) -> &'a mut crate::generated::all::builders::OptionBuilder,
3096        {
3097            let ty: crate::generated::all::Option = Default::default();
3098            let mut ty_builder = crate::generated::all::builders::OptionBuilder::new(ty);
3099            (f)(&mut ty_builder);
3100            let ty = ty_builder.build();
3101            self.element.children_mut().push(ty.into());
3102            self
3103        }
3104        /// Append a new `OptionGroup` element
3105        pub fn option_group<F>(&mut self, f: F) -> &mut Self
3106        where
3107            F: for<'a> FnOnce(
3108                &'a mut crate::generated::all::builders::OptionGroupBuilder,
3109            ) -> &'a mut crate::generated::all::builders::OptionGroupBuilder,
3110        {
3111            let ty: crate::generated::all::OptionGroup = Default::default();
3112            let mut ty_builder = crate::generated::all::builders::OptionGroupBuilder::new(
3113                ty,
3114            );
3115            (f)(&mut ty_builder);
3116            let ty = ty_builder.build();
3117            self.element.children_mut().push(ty.into());
3118            self
3119        }
3120        /// Append a new `OrderedList` element
3121        pub fn ordered_list<F>(&mut self, f: F) -> &mut Self
3122        where
3123            F: for<'a> FnOnce(
3124                &'a mut crate::generated::all::builders::OrderedListBuilder,
3125            ) -> &'a mut crate::generated::all::builders::OrderedListBuilder,
3126        {
3127            let ty: crate::generated::all::OrderedList = Default::default();
3128            let mut ty_builder = crate::generated::all::builders::OrderedListBuilder::new(
3129                ty,
3130            );
3131            (f)(&mut ty_builder);
3132            let ty = ty_builder.build();
3133            self.element.children_mut().push(ty.into());
3134            self
3135        }
3136        /// Append a new `Output` element
3137        pub fn output<F>(&mut self, f: F) -> &mut Self
3138        where
3139            F: for<'a> FnOnce(
3140                &'a mut crate::generated::all::builders::OutputBuilder,
3141            ) -> &'a mut crate::generated::all::builders::OutputBuilder,
3142        {
3143            let ty: crate::generated::all::Output = Default::default();
3144            let mut ty_builder = crate::generated::all::builders::OutputBuilder::new(ty);
3145            (f)(&mut ty_builder);
3146            let ty = ty_builder.build();
3147            self.element.children_mut().push(ty.into());
3148            self
3149        }
3150        /// Append a new `Paragraph` element
3151        pub fn paragraph<F>(&mut self, f: F) -> &mut Self
3152        where
3153            F: for<'a> FnOnce(
3154                &'a mut crate::generated::all::builders::ParagraphBuilder,
3155            ) -> &'a mut crate::generated::all::builders::ParagraphBuilder,
3156        {
3157            let ty: crate::generated::all::Paragraph = Default::default();
3158            let mut ty_builder = crate::generated::all::builders::ParagraphBuilder::new(
3159                ty,
3160            );
3161            (f)(&mut ty_builder);
3162            let ty = ty_builder.build();
3163            self.element.children_mut().push(ty.into());
3164            self
3165        }
3166        /// Append a new `Picture` element
3167        pub fn picture<F>(&mut self, f: F) -> &mut Self
3168        where
3169            F: for<'a> FnOnce(
3170                &'a mut crate::generated::all::builders::PictureBuilder,
3171            ) -> &'a mut crate::generated::all::builders::PictureBuilder,
3172        {
3173            let ty: crate::generated::all::Picture = Default::default();
3174            let mut ty_builder = crate::generated::all::builders::PictureBuilder::new(
3175                ty,
3176            );
3177            (f)(&mut ty_builder);
3178            let ty = ty_builder.build();
3179            self.element.children_mut().push(ty.into());
3180            self
3181        }
3182        /// Append a new `PreformattedText` element
3183        pub fn preformatted_text<F>(&mut self, f: F) -> &mut Self
3184        where
3185            F: for<'a> FnOnce(
3186                &'a mut crate::generated::all::builders::PreformattedTextBuilder,
3187            ) -> &'a mut crate::generated::all::builders::PreformattedTextBuilder,
3188        {
3189            let ty: crate::generated::all::PreformattedText = Default::default();
3190            let mut ty_builder = crate::generated::all::builders::PreformattedTextBuilder::new(
3191                ty,
3192            );
3193            (f)(&mut ty_builder);
3194            let ty = ty_builder.build();
3195            self.element.children_mut().push(ty.into());
3196            self
3197        }
3198        /// Append a new `Progress` element
3199        pub fn progress<F>(&mut self, f: F) -> &mut Self
3200        where
3201            F: for<'a> FnOnce(
3202                &'a mut crate::generated::all::builders::ProgressBuilder,
3203            ) -> &'a mut crate::generated::all::builders::ProgressBuilder,
3204        {
3205            let ty: crate::generated::all::Progress = Default::default();
3206            let mut ty_builder = crate::generated::all::builders::ProgressBuilder::new(
3207                ty,
3208            );
3209            (f)(&mut ty_builder);
3210            let ty = ty_builder.build();
3211            self.element.children_mut().push(ty.into());
3212            self
3213        }
3214        /// Append a new `Quotation` element
3215        pub fn quotation<F>(&mut self, f: F) -> &mut Self
3216        where
3217            F: for<'a> FnOnce(
3218                &'a mut crate::generated::all::builders::QuotationBuilder,
3219            ) -> &'a mut crate::generated::all::builders::QuotationBuilder,
3220        {
3221            let ty: crate::generated::all::Quotation = Default::default();
3222            let mut ty_builder = crate::generated::all::builders::QuotationBuilder::new(
3223                ty,
3224            );
3225            (f)(&mut ty_builder);
3226            let ty = ty_builder.build();
3227            self.element.children_mut().push(ty.into());
3228            self
3229        }
3230        /// Append a new `RubyAnnotation` element
3231        pub fn ruby_annotation<F>(&mut self, f: F) -> &mut Self
3232        where
3233            F: for<'a> FnOnce(
3234                &'a mut crate::generated::all::builders::RubyAnnotationBuilder,
3235            ) -> &'a mut crate::generated::all::builders::RubyAnnotationBuilder,
3236        {
3237            let ty: crate::generated::all::RubyAnnotation = Default::default();
3238            let mut ty_builder = crate::generated::all::builders::RubyAnnotationBuilder::new(
3239                ty,
3240            );
3241            (f)(&mut ty_builder);
3242            let ty = ty_builder.build();
3243            self.element.children_mut().push(ty.into());
3244            self
3245        }
3246        /// Append a new `RubyFallbackParenthesis` element
3247        pub fn ruby_fallback_parenthesis<F>(&mut self, f: F) -> &mut Self
3248        where
3249            F: for<'a> FnOnce(
3250                &'a mut crate::generated::all::builders::RubyFallbackParenthesisBuilder,
3251            ) -> &'a mut crate::generated::all::builders::RubyFallbackParenthesisBuilder,
3252        {
3253            let ty: crate::generated::all::RubyFallbackParenthesis = Default::default();
3254            let mut ty_builder = crate::generated::all::builders::RubyFallbackParenthesisBuilder::new(
3255                ty,
3256            );
3257            (f)(&mut ty_builder);
3258            let ty = ty_builder.build();
3259            self.element.children_mut().push(ty.into());
3260            self
3261        }
3262        /// Append a new `RubyText` element
3263        pub fn ruby_text<F>(&mut self, f: F) -> &mut Self
3264        where
3265            F: for<'a> FnOnce(
3266                &'a mut crate::generated::all::builders::RubyTextBuilder,
3267            ) -> &'a mut crate::generated::all::builders::RubyTextBuilder,
3268        {
3269            let ty: crate::generated::all::RubyText = Default::default();
3270            let mut ty_builder = crate::generated::all::builders::RubyTextBuilder::new(
3271                ty,
3272            );
3273            (f)(&mut ty_builder);
3274            let ty = ty_builder.build();
3275            self.element.children_mut().push(ty.into());
3276            self
3277        }
3278        /// Append a new `SampleOutput` element
3279        pub fn sample_output<F>(&mut self, f: F) -> &mut Self
3280        where
3281            F: for<'a> FnOnce(
3282                &'a mut crate::generated::all::builders::SampleOutputBuilder,
3283            ) -> &'a mut crate::generated::all::builders::SampleOutputBuilder,
3284        {
3285            let ty: crate::generated::all::SampleOutput = Default::default();
3286            let mut ty_builder = crate::generated::all::builders::SampleOutputBuilder::new(
3287                ty,
3288            );
3289            (f)(&mut ty_builder);
3290            let ty = ty_builder.build();
3291            self.element.children_mut().push(ty.into());
3292            self
3293        }
3294        /// Append a new `Script` element
3295        pub fn script<F>(&mut self, f: F) -> &mut Self
3296        where
3297            F: for<'a> FnOnce(
3298                &'a mut crate::generated::all::builders::ScriptBuilder,
3299            ) -> &'a mut crate::generated::all::builders::ScriptBuilder,
3300        {
3301            let ty: crate::generated::all::Script = Default::default();
3302            let mut ty_builder = crate::generated::all::builders::ScriptBuilder::new(ty);
3303            (f)(&mut ty_builder);
3304            let ty = ty_builder.build();
3305            self.element.children_mut().push(ty.into());
3306            self
3307        }
3308        /// Append a new `Search` element
3309        pub fn search<F>(&mut self, f: F) -> &mut Self
3310        where
3311            F: for<'a> FnOnce(
3312                &'a mut crate::generated::all::builders::SearchBuilder,
3313            ) -> &'a mut crate::generated::all::builders::SearchBuilder,
3314        {
3315            let ty: crate::generated::all::Search = Default::default();
3316            let mut ty_builder = crate::generated::all::builders::SearchBuilder::new(ty);
3317            (f)(&mut ty_builder);
3318            let ty = ty_builder.build();
3319            self.element.children_mut().push(ty.into());
3320            self
3321        }
3322        /// Append a new `Section` element
3323        pub fn section<F>(&mut self, f: F) -> &mut Self
3324        where
3325            F: for<'a> FnOnce(
3326                &'a mut crate::generated::all::builders::SectionBuilder,
3327            ) -> &'a mut crate::generated::all::builders::SectionBuilder,
3328        {
3329            let ty: crate::generated::all::Section = Default::default();
3330            let mut ty_builder = crate::generated::all::builders::SectionBuilder::new(
3331                ty,
3332            );
3333            (f)(&mut ty_builder);
3334            let ty = ty_builder.build();
3335            self.element.children_mut().push(ty.into());
3336            self
3337        }
3338        /// Append a new `Select` element
3339        pub fn select<F>(&mut self, f: F) -> &mut Self
3340        where
3341            F: for<'a> FnOnce(
3342                &'a mut crate::generated::all::builders::SelectBuilder,
3343            ) -> &'a mut crate::generated::all::builders::SelectBuilder,
3344        {
3345            let ty: crate::generated::all::Select = Default::default();
3346            let mut ty_builder = crate::generated::all::builders::SelectBuilder::new(ty);
3347            (f)(&mut ty_builder);
3348            let ty = ty_builder.build();
3349            self.element.children_mut().push(ty.into());
3350            self
3351        }
3352        /// Append a new `SideComment` element
3353        pub fn side_comment<F>(&mut self, f: F) -> &mut Self
3354        where
3355            F: for<'a> FnOnce(
3356                &'a mut crate::generated::all::builders::SideCommentBuilder,
3357            ) -> &'a mut crate::generated::all::builders::SideCommentBuilder,
3358        {
3359            let ty: crate::generated::all::SideComment = Default::default();
3360            let mut ty_builder = crate::generated::all::builders::SideCommentBuilder::new(
3361                ty,
3362            );
3363            (f)(&mut ty_builder);
3364            let ty = ty_builder.build();
3365            self.element.children_mut().push(ty.into());
3366            self
3367        }
3368        /// Append a new `Slot` element
3369        pub fn slot<F>(&mut self, f: F) -> &mut Self
3370        where
3371            F: for<'a> FnOnce(
3372                &'a mut crate::generated::all::builders::SlotBuilder,
3373            ) -> &'a mut crate::generated::all::builders::SlotBuilder,
3374        {
3375            let ty: crate::generated::all::Slot = Default::default();
3376            let mut ty_builder = crate::generated::all::builders::SlotBuilder::new(ty);
3377            (f)(&mut ty_builder);
3378            let ty = ty_builder.build();
3379            self.element.children_mut().push(ty.into());
3380            self
3381        }
3382        /// Append a new `Span` element
3383        pub fn span<F>(&mut self, f: F) -> &mut Self
3384        where
3385            F: for<'a> FnOnce(
3386                &'a mut crate::generated::all::builders::SpanBuilder,
3387            ) -> &'a mut crate::generated::all::builders::SpanBuilder,
3388        {
3389            let ty: crate::generated::all::Span = Default::default();
3390            let mut ty_builder = crate::generated::all::builders::SpanBuilder::new(ty);
3391            (f)(&mut ty_builder);
3392            let ty = ty_builder.build();
3393            self.element.children_mut().push(ty.into());
3394            self
3395        }
3396        /// Append a new `StrikeThrough` element
3397        pub fn strike_through<F>(&mut self, f: F) -> &mut Self
3398        where
3399            F: for<'a> FnOnce(
3400                &'a mut crate::generated::all::builders::StrikeThroughBuilder,
3401            ) -> &'a mut crate::generated::all::builders::StrikeThroughBuilder,
3402        {
3403            let ty: crate::generated::all::StrikeThrough = Default::default();
3404            let mut ty_builder = crate::generated::all::builders::StrikeThroughBuilder::new(
3405                ty,
3406            );
3407            (f)(&mut ty_builder);
3408            let ty = ty_builder.build();
3409            self.element.children_mut().push(ty.into());
3410            self
3411        }
3412        /// Append a new `Strong` element
3413        pub fn strong<F>(&mut self, f: F) -> &mut Self
3414        where
3415            F: for<'a> FnOnce(
3416                &'a mut crate::generated::all::builders::StrongBuilder,
3417            ) -> &'a mut crate::generated::all::builders::StrongBuilder,
3418        {
3419            let ty: crate::generated::all::Strong = Default::default();
3420            let mut ty_builder = crate::generated::all::builders::StrongBuilder::new(ty);
3421            (f)(&mut ty_builder);
3422            let ty = ty_builder.build();
3423            self.element.children_mut().push(ty.into());
3424            self
3425        }
3426        /// Append a new `Style` element
3427        pub fn style<F>(&mut self, f: F) -> &mut Self
3428        where
3429            F: for<'a> FnOnce(
3430                &'a mut crate::generated::all::builders::StyleBuilder,
3431            ) -> &'a mut crate::generated::all::builders::StyleBuilder,
3432        {
3433            let ty: crate::generated::all::Style = Default::default();
3434            let mut ty_builder = crate::generated::all::builders::StyleBuilder::new(ty);
3435            (f)(&mut ty_builder);
3436            let ty = ty_builder.build();
3437            self.element.children_mut().push(ty.into());
3438            self
3439        }
3440        /// Append a new `SubScript` element
3441        pub fn sub_script<F>(&mut self, f: F) -> &mut Self
3442        where
3443            F: for<'a> FnOnce(
3444                &'a mut crate::generated::all::builders::SubScriptBuilder,
3445            ) -> &'a mut crate::generated::all::builders::SubScriptBuilder,
3446        {
3447            let ty: crate::generated::all::SubScript = Default::default();
3448            let mut ty_builder = crate::generated::all::builders::SubScriptBuilder::new(
3449                ty,
3450            );
3451            (f)(&mut ty_builder);
3452            let ty = ty_builder.build();
3453            self.element.children_mut().push(ty.into());
3454            self
3455        }
3456        /// Append a new `Summary` element
3457        pub fn summary<F>(&mut self, f: F) -> &mut Self
3458        where
3459            F: for<'a> FnOnce(
3460                &'a mut crate::generated::all::builders::SummaryBuilder,
3461            ) -> &'a mut crate::generated::all::builders::SummaryBuilder,
3462        {
3463            let ty: crate::generated::all::Summary = Default::default();
3464            let mut ty_builder = crate::generated::all::builders::SummaryBuilder::new(
3465                ty,
3466            );
3467            (f)(&mut ty_builder);
3468            let ty = ty_builder.build();
3469            self.element.children_mut().push(ty.into());
3470            self
3471        }
3472        /// Append a new `SuperScript` element
3473        pub fn super_script<F>(&mut self, f: F) -> &mut Self
3474        where
3475            F: for<'a> FnOnce(
3476                &'a mut crate::generated::all::builders::SuperScriptBuilder,
3477            ) -> &'a mut crate::generated::all::builders::SuperScriptBuilder,
3478        {
3479            let ty: crate::generated::all::SuperScript = Default::default();
3480            let mut ty_builder = crate::generated::all::builders::SuperScriptBuilder::new(
3481                ty,
3482            );
3483            (f)(&mut ty_builder);
3484            let ty = ty_builder.build();
3485            self.element.children_mut().push(ty.into());
3486            self
3487        }
3488        /// Append a new `Table` element
3489        pub fn table<F>(&mut self, f: F) -> &mut Self
3490        where
3491            F: for<'a> FnOnce(
3492                &'a mut crate::generated::all::builders::TableBuilder,
3493            ) -> &'a mut crate::generated::all::builders::TableBuilder,
3494        {
3495            let ty: crate::generated::all::Table = Default::default();
3496            let mut ty_builder = crate::generated::all::builders::TableBuilder::new(ty);
3497            (f)(&mut ty_builder);
3498            let ty = ty_builder.build();
3499            self.element.children_mut().push(ty.into());
3500            self
3501        }
3502        /// Append a new `TableBody` element
3503        pub fn table_body<F>(&mut self, f: F) -> &mut Self
3504        where
3505            F: for<'a> FnOnce(
3506                &'a mut crate::generated::all::builders::TableBodyBuilder,
3507            ) -> &'a mut crate::generated::all::builders::TableBodyBuilder,
3508        {
3509            let ty: crate::generated::all::TableBody = Default::default();
3510            let mut ty_builder = crate::generated::all::builders::TableBodyBuilder::new(
3511                ty,
3512            );
3513            (f)(&mut ty_builder);
3514            let ty = ty_builder.build();
3515            self.element.children_mut().push(ty.into());
3516            self
3517        }
3518        /// Append a new `TableCell` element
3519        pub fn table_cell<F>(&mut self, f: F) -> &mut Self
3520        where
3521            F: for<'a> FnOnce(
3522                &'a mut crate::generated::all::builders::TableCellBuilder,
3523            ) -> &'a mut crate::generated::all::builders::TableCellBuilder,
3524        {
3525            let ty: crate::generated::all::TableCell = Default::default();
3526            let mut ty_builder = crate::generated::all::builders::TableCellBuilder::new(
3527                ty,
3528            );
3529            (f)(&mut ty_builder);
3530            let ty = ty_builder.build();
3531            self.element.children_mut().push(ty.into());
3532            self
3533        }
3534        /// Append a new `TableColumn` element
3535        pub fn table_column<F>(&mut self, f: F) -> &mut Self
3536        where
3537            F: for<'a> FnOnce(
3538                &'a mut crate::generated::all::builders::TableColumnBuilder,
3539            ) -> &'a mut crate::generated::all::builders::TableColumnBuilder,
3540        {
3541            let ty: crate::generated::all::TableColumn = Default::default();
3542            let mut ty_builder = crate::generated::all::builders::TableColumnBuilder::new(
3543                ty,
3544            );
3545            (f)(&mut ty_builder);
3546            let ty = ty_builder.build();
3547            self.element.children_mut().push(ty.into());
3548            self
3549        }
3550        /// Append a new `TableColumnGroup` element
3551        pub fn table_column_group<F>(&mut self, f: F) -> &mut Self
3552        where
3553            F: for<'a> FnOnce(
3554                &'a mut crate::generated::all::builders::TableColumnGroupBuilder,
3555            ) -> &'a mut crate::generated::all::builders::TableColumnGroupBuilder,
3556        {
3557            let ty: crate::generated::all::TableColumnGroup = Default::default();
3558            let mut ty_builder = crate::generated::all::builders::TableColumnGroupBuilder::new(
3559                ty,
3560            );
3561            (f)(&mut ty_builder);
3562            let ty = ty_builder.build();
3563            self.element.children_mut().push(ty.into());
3564            self
3565        }
3566        /// Append a new `TableFoot` element
3567        pub fn table_foot<F>(&mut self, f: F) -> &mut Self
3568        where
3569            F: for<'a> FnOnce(
3570                &'a mut crate::generated::all::builders::TableFootBuilder,
3571            ) -> &'a mut crate::generated::all::builders::TableFootBuilder,
3572        {
3573            let ty: crate::generated::all::TableFoot = Default::default();
3574            let mut ty_builder = crate::generated::all::builders::TableFootBuilder::new(
3575                ty,
3576            );
3577            (f)(&mut ty_builder);
3578            let ty = ty_builder.build();
3579            self.element.children_mut().push(ty.into());
3580            self
3581        }
3582        /// Append a new `TableHead` element
3583        pub fn table_head<F>(&mut self, f: F) -> &mut Self
3584        where
3585            F: for<'a> FnOnce(
3586                &'a mut crate::generated::all::builders::TableHeadBuilder,
3587            ) -> &'a mut crate::generated::all::builders::TableHeadBuilder,
3588        {
3589            let ty: crate::generated::all::TableHead = Default::default();
3590            let mut ty_builder = crate::generated::all::builders::TableHeadBuilder::new(
3591                ty,
3592            );
3593            (f)(&mut ty_builder);
3594            let ty = ty_builder.build();
3595            self.element.children_mut().push(ty.into());
3596            self
3597        }
3598        /// Append a new `TableHeader` element
3599        pub fn table_header<F>(&mut self, f: F) -> &mut Self
3600        where
3601            F: for<'a> FnOnce(
3602                &'a mut crate::generated::all::builders::TableHeaderBuilder,
3603            ) -> &'a mut crate::generated::all::builders::TableHeaderBuilder,
3604        {
3605            let ty: crate::generated::all::TableHeader = Default::default();
3606            let mut ty_builder = crate::generated::all::builders::TableHeaderBuilder::new(
3607                ty,
3608            );
3609            (f)(&mut ty_builder);
3610            let ty = ty_builder.build();
3611            self.element.children_mut().push(ty.into());
3612            self
3613        }
3614        /// Append a new `TableRow` element
3615        pub fn table_row<F>(&mut self, f: F) -> &mut Self
3616        where
3617            F: for<'a> FnOnce(
3618                &'a mut crate::generated::all::builders::TableRowBuilder,
3619            ) -> &'a mut crate::generated::all::builders::TableRowBuilder,
3620        {
3621            let ty: crate::generated::all::TableRow = Default::default();
3622            let mut ty_builder = crate::generated::all::builders::TableRowBuilder::new(
3623                ty,
3624            );
3625            (f)(&mut ty_builder);
3626            let ty = ty_builder.build();
3627            self.element.children_mut().push(ty.into());
3628            self
3629        }
3630        /// Append a new `Template` element
3631        pub fn template<F>(&mut self, f: F) -> &mut Self
3632        where
3633            F: for<'a> FnOnce(
3634                &'a mut crate::generated::all::builders::TemplateBuilder,
3635            ) -> &'a mut crate::generated::all::builders::TemplateBuilder,
3636        {
3637            let ty: crate::generated::all::Template = Default::default();
3638            let mut ty_builder = crate::generated::all::builders::TemplateBuilder::new(
3639                ty,
3640            );
3641            (f)(&mut ty_builder);
3642            let ty = ty_builder.build();
3643            self.element.children_mut().push(ty.into());
3644            self
3645        }
3646        /// Append a new text element.
3647        pub fn text(
3648            &mut self,
3649            s: impl Into<std::borrow::Cow<'static, str>>,
3650        ) -> &mut Self {
3651            let cow = s.into();
3652            self.element.children_mut().push(cow.into());
3653            self
3654        }
3655        /// Append a new `TextArea` element
3656        pub fn text_area<F>(&mut self, f: F) -> &mut Self
3657        where
3658            F: for<'a> FnOnce(
3659                &'a mut crate::generated::all::builders::TextAreaBuilder,
3660            ) -> &'a mut crate::generated::all::builders::TextAreaBuilder,
3661        {
3662            let ty: crate::generated::all::TextArea = Default::default();
3663            let mut ty_builder = crate::generated::all::builders::TextAreaBuilder::new(
3664                ty,
3665            );
3666            (f)(&mut ty_builder);
3667            let ty = ty_builder.build();
3668            self.element.children_mut().push(ty.into());
3669            self
3670        }
3671        /// Append a new `TextTrack` element
3672        pub fn text_track<F>(&mut self, f: F) -> &mut Self
3673        where
3674            F: for<'a> FnOnce(
3675                &'a mut crate::generated::all::builders::TextTrackBuilder,
3676            ) -> &'a mut crate::generated::all::builders::TextTrackBuilder,
3677        {
3678            let ty: crate::generated::all::TextTrack = Default::default();
3679            let mut ty_builder = crate::generated::all::builders::TextTrackBuilder::new(
3680                ty,
3681            );
3682            (f)(&mut ty_builder);
3683            let ty = ty_builder.build();
3684            self.element.children_mut().push(ty.into());
3685            self
3686        }
3687        /// Append a new `ThematicBreak` element
3688        pub fn thematic_break<F>(&mut self, f: F) -> &mut Self
3689        where
3690            F: for<'a> FnOnce(
3691                &'a mut crate::generated::all::builders::ThematicBreakBuilder,
3692            ) -> &'a mut crate::generated::all::builders::ThematicBreakBuilder,
3693        {
3694            let ty: crate::generated::all::ThematicBreak = Default::default();
3695            let mut ty_builder = crate::generated::all::builders::ThematicBreakBuilder::new(
3696                ty,
3697            );
3698            (f)(&mut ty_builder);
3699            let ty = ty_builder.build();
3700            self.element.children_mut().push(ty.into());
3701            self
3702        }
3703        /// Append a new `Time` element
3704        pub fn time<F>(&mut self, f: F) -> &mut Self
3705        where
3706            F: for<'a> FnOnce(
3707                &'a mut crate::generated::all::builders::TimeBuilder,
3708            ) -> &'a mut crate::generated::all::builders::TimeBuilder,
3709        {
3710            let ty: crate::generated::all::Time = Default::default();
3711            let mut ty_builder = crate::generated::all::builders::TimeBuilder::new(ty);
3712            (f)(&mut ty_builder);
3713            let ty = ty_builder.build();
3714            self.element.children_mut().push(ty.into());
3715            self
3716        }
3717        /// Append a new `Title` element
3718        pub fn title<F>(&mut self, f: F) -> &mut Self
3719        where
3720            F: for<'a> FnOnce(
3721                &'a mut crate::generated::all::builders::TitleBuilder,
3722            ) -> &'a mut crate::generated::all::builders::TitleBuilder,
3723        {
3724            let ty: crate::generated::all::Title = Default::default();
3725            let mut ty_builder = crate::generated::all::builders::TitleBuilder::new(ty);
3726            (f)(&mut ty_builder);
3727            let ty = ty_builder.build();
3728            self.element.children_mut().push(ty.into());
3729            self
3730        }
3731        /// Append a new `Underline` element
3732        pub fn underline<F>(&mut self, f: F) -> &mut Self
3733        where
3734            F: for<'a> FnOnce(
3735                &'a mut crate::generated::all::builders::UnderlineBuilder,
3736            ) -> &'a mut crate::generated::all::builders::UnderlineBuilder,
3737        {
3738            let ty: crate::generated::all::Underline = Default::default();
3739            let mut ty_builder = crate::generated::all::builders::UnderlineBuilder::new(
3740                ty,
3741            );
3742            (f)(&mut ty_builder);
3743            let ty = ty_builder.build();
3744            self.element.children_mut().push(ty.into());
3745            self
3746        }
3747        /// Append a new `UnorderedList` element
3748        pub fn unordered_list<F>(&mut self, f: F) -> &mut Self
3749        where
3750            F: for<'a> FnOnce(
3751                &'a mut crate::generated::all::builders::UnorderedListBuilder,
3752            ) -> &'a mut crate::generated::all::builders::UnorderedListBuilder,
3753        {
3754            let ty: crate::generated::all::UnorderedList = Default::default();
3755            let mut ty_builder = crate::generated::all::builders::UnorderedListBuilder::new(
3756                ty,
3757            );
3758            (f)(&mut ty_builder);
3759            let ty = ty_builder.build();
3760            self.element.children_mut().push(ty.into());
3761            self
3762        }
3763        /// Append a new `Variable` element
3764        pub fn variable<F>(&mut self, f: F) -> &mut Self
3765        where
3766            F: for<'a> FnOnce(
3767                &'a mut crate::generated::all::builders::VariableBuilder,
3768            ) -> &'a mut crate::generated::all::builders::VariableBuilder,
3769        {
3770            let ty: crate::generated::all::Variable = Default::default();
3771            let mut ty_builder = crate::generated::all::builders::VariableBuilder::new(
3772                ty,
3773            );
3774            (f)(&mut ty_builder);
3775            let ty = ty_builder.build();
3776            self.element.children_mut().push(ty.into());
3777            self
3778        }
3779        /// Append a new `Video` element
3780        pub fn video<F>(&mut self, f: F) -> &mut Self
3781        where
3782            F: for<'a> FnOnce(
3783                &'a mut crate::generated::all::builders::VideoBuilder,
3784            ) -> &'a mut crate::generated::all::builders::VideoBuilder,
3785        {
3786            let ty: crate::generated::all::Video = Default::default();
3787            let mut ty_builder = crate::generated::all::builders::VideoBuilder::new(ty);
3788            (f)(&mut ty_builder);
3789            let ty = ty_builder.build();
3790            self.element.children_mut().push(ty.into());
3791            self
3792        }
3793        /// Set the value of the `href` attribute
3794        pub fn href(
3795            &mut self,
3796            value: impl Into<std::borrow::Cow<'static, str>>,
3797        ) -> &mut Self {
3798            self.element.set_href(Some(value.into()));
3799            self
3800        }
3801        /// Set the value of the `target` attribute
3802        pub fn target(
3803            &mut self,
3804            value: impl Into<std::borrow::Cow<'static, str>>,
3805        ) -> &mut Self {
3806            self.element.set_target(Some(value.into()));
3807            self
3808        }
3809        /// Set the value of the `download` attribute
3810        pub fn download(
3811            &mut self,
3812            value: impl Into<std::borrow::Cow<'static, str>>,
3813        ) -> &mut Self {
3814            self.element.set_download(Some(value.into()));
3815            self
3816        }
3817        /// Set the value of the `ping` attribute
3818        pub fn ping(
3819            &mut self,
3820            value: impl Into<std::borrow::Cow<'static, str>>,
3821        ) -> &mut Self {
3822            self.element.set_ping(Some(value.into()));
3823            self
3824        }
3825        /// Set the value of the `rel` attribute
3826        pub fn rel(
3827            &mut self,
3828            value: impl Into<std::borrow::Cow<'static, str>>,
3829        ) -> &mut Self {
3830            self.element.set_rel(Some(value.into()));
3831            self
3832        }
3833        /// Set the value of the `hreflang` attribute
3834        pub fn hreflang(
3835            &mut self,
3836            value: impl Into<std::borrow::Cow<'static, str>>,
3837        ) -> &mut Self {
3838            self.element.set_hreflang(Some(value.into()));
3839            self
3840        }
3841        /// Set the value of the `type` attribute
3842        pub fn type_(
3843            &mut self,
3844            value: impl Into<std::borrow::Cow<'static, str>>,
3845        ) -> &mut Self {
3846            self.element.set_type_(Some(value.into()));
3847            self
3848        }
3849        /// Set the value of the `referrerpolicy` attribute
3850        pub fn referrerpolicy(
3851            &mut self,
3852            value: impl Into<std::borrow::Cow<'static, str>>,
3853        ) -> &mut Self {
3854            self.element.set_referrerpolicy(Some(value.into()));
3855            self
3856        }
3857        /// Set the value of the `role` attribute
3858        pub fn role(
3859            &mut self,
3860            value: impl Into<std::borrow::Cow<'static, str>>,
3861        ) -> &mut Self {
3862            self.element.set_role(Some(value.into()));
3863            self
3864        }
3865        /// Set the value of the `aria-activedescendant` attribute
3866        pub fn aria_active_descendant_element(
3867            &mut self,
3868            value: impl Into<std::borrow::Cow<'static, str>>,
3869        ) -> &mut Self {
3870            self.element.set_aria_active_descendant_element(Some(value.into()));
3871            self
3872        }
3873        /// Set the value of the `aria-atomic` attribute
3874        pub fn aria_atomic(&mut self, value: bool) -> &mut Self {
3875            self.element.set_aria_atomic(value);
3876            self
3877        }
3878        /// Set the value of the `aria-autocomplete` attribute
3879        pub fn aria_auto_complete(
3880            &mut self,
3881            value: impl Into<std::borrow::Cow<'static, str>>,
3882        ) -> &mut Self {
3883            self.element.set_aria_auto_complete(Some(value.into()));
3884            self
3885        }
3886        /// Set the value of the `aria-braillelabel` attribute
3887        pub fn aria_braille_label(
3888            &mut self,
3889            value: impl Into<std::borrow::Cow<'static, str>>,
3890        ) -> &mut Self {
3891            self.element.set_aria_braille_label(Some(value.into()));
3892            self
3893        }
3894        /// Set the value of the `aria-brailleroledescription` attribute
3895        pub fn aria_braille_role_description(
3896            &mut self,
3897            value: impl Into<std::borrow::Cow<'static, str>>,
3898        ) -> &mut Self {
3899            self.element.set_aria_braille_role_description(Some(value.into()));
3900            self
3901        }
3902        /// Set the value of the `aria-busy` attribute
3903        pub fn aria_busy(&mut self, value: bool) -> &mut Self {
3904            self.element.set_aria_busy(value);
3905            self
3906        }
3907        /// Set the value of the `aria-checked` attribute
3908        pub fn aria_checked(
3909            &mut self,
3910            value: impl Into<std::borrow::Cow<'static, str>>,
3911        ) -> &mut Self {
3912            self.element.set_aria_checked(Some(value.into()));
3913            self
3914        }
3915        /// Set the value of the `aria-colcount` attribute
3916        pub fn aria_col_count(&mut self, value: i64) -> &mut Self {
3917            self.element.set_aria_col_count(Some(value));
3918            self
3919        }
3920        /// Set the value of the `aria-colindex` attribute
3921        pub fn aria_col_index(&mut self, value: i64) -> &mut Self {
3922            self.element.set_aria_col_index(Some(value));
3923            self
3924        }
3925        /// Set the value of the `aria-colindextext` attribute
3926        pub fn aria_col_index_text(
3927            &mut self,
3928            value: impl Into<std::borrow::Cow<'static, str>>,
3929        ) -> &mut Self {
3930            self.element.set_aria_col_index_text(Some(value.into()));
3931            self
3932        }
3933        /// Set the value of the `aria-colspan` attribute
3934        pub fn aria_col_span(&mut self, value: i64) -> &mut Self {
3935            self.element.set_aria_col_span(Some(value));
3936            self
3937        }
3938        /// Set the value of the `aria-controls` attribute
3939        pub fn aria_controls_elements(
3940            &mut self,
3941            value: impl Into<std::borrow::Cow<'static, str>>,
3942        ) -> &mut Self {
3943            self.element.set_aria_controls_elements(Some(value.into()));
3944            self
3945        }
3946        /// Set the value of the `aria-current` attribute
3947        pub fn aria_current(
3948            &mut self,
3949            value: impl Into<std::borrow::Cow<'static, str>>,
3950        ) -> &mut Self {
3951            self.element.set_aria_current(Some(value.into()));
3952            self
3953        }
3954        /// Set the value of the `aria-describedby` attribute
3955        pub fn aria_described_by_elements(
3956            &mut self,
3957            value: impl Into<std::borrow::Cow<'static, str>>,
3958        ) -> &mut Self {
3959            self.element.set_aria_described_by_elements(Some(value.into()));
3960            self
3961        }
3962        /// Set the value of the `aria-description` attribute
3963        pub fn aria_description(
3964            &mut self,
3965            value: impl Into<std::borrow::Cow<'static, str>>,
3966        ) -> &mut Self {
3967            self.element.set_aria_description(Some(value.into()));
3968            self
3969        }
3970        /// Set the value of the `aria-details` attribute
3971        pub fn aria_details_elements(
3972            &mut self,
3973            value: impl Into<std::borrow::Cow<'static, str>>,
3974        ) -> &mut Self {
3975            self.element.set_aria_details_elements(Some(value.into()));
3976            self
3977        }
3978        /// Set the value of the `aria-disabled` attribute
3979        pub fn aria_disabled(&mut self, value: bool) -> &mut Self {
3980            self.element.set_aria_disabled(value);
3981            self
3982        }
3983        /// Set the value of the `aria-dropeffect` attribute
3984        pub fn aria_drop_effect(
3985            &mut self,
3986            value: impl Into<std::borrow::Cow<'static, str>>,
3987        ) -> &mut Self {
3988            self.element.set_aria_drop_effect(Some(value.into()));
3989            self
3990        }
3991        /// Set the value of the `aria-errormessage` attribute
3992        pub fn aria_error_message_elements(
3993            &mut self,
3994            value: impl Into<std::borrow::Cow<'static, str>>,
3995        ) -> &mut Self {
3996            self.element.set_aria_error_message_elements(Some(value.into()));
3997            self
3998        }
3999        /// Set the value of the `aria-expanded` attribute
4000        pub fn aria_expanded(&mut self, value: bool) -> &mut Self {
4001            self.element.set_aria_expanded(value);
4002            self
4003        }
4004        /// Set the value of the `aria-flowto` attribute
4005        pub fn aria_flow_to_elements(
4006            &mut self,
4007            value: impl Into<std::borrow::Cow<'static, str>>,
4008        ) -> &mut Self {
4009            self.element.set_aria_flow_to_elements(Some(value.into()));
4010            self
4011        }
4012        /// Set the value of the `aria-grabbed` attribute
4013        pub fn aria_grabbed(&mut self, value: bool) -> &mut Self {
4014            self.element.set_aria_grabbed(value);
4015            self
4016        }
4017        /// Set the value of the `aria-haspopup` attribute
4018        pub fn aria_has_popup(
4019            &mut self,
4020            value: impl Into<std::borrow::Cow<'static, str>>,
4021        ) -> &mut Self {
4022            self.element.set_aria_has_popup(Some(value.into()));
4023            self
4024        }
4025        /// Set the value of the `aria-hidden` attribute
4026        pub fn aria_hidden(&mut self, value: bool) -> &mut Self {
4027            self.element.set_aria_hidden(value);
4028            self
4029        }
4030        /// Set the value of the `aria-invalid` attribute
4031        pub fn aria_invalid(
4032            &mut self,
4033            value: impl Into<std::borrow::Cow<'static, str>>,
4034        ) -> &mut Self {
4035            self.element.set_aria_invalid(Some(value.into()));
4036            self
4037        }
4038        /// Set the value of the `aria-keyshortcuts` attribute
4039        pub fn aria_key_shortcuts(
4040            &mut self,
4041            value: impl Into<std::borrow::Cow<'static, str>>,
4042        ) -> &mut Self {
4043            self.element.set_aria_key_shortcuts(Some(value.into()));
4044            self
4045        }
4046        /// Set the value of the `aria-label` attribute
4047        pub fn aria_label(
4048            &mut self,
4049            value: impl Into<std::borrow::Cow<'static, str>>,
4050        ) -> &mut Self {
4051            self.element.set_aria_label(Some(value.into()));
4052            self
4053        }
4054        /// Set the value of the `aria-labelledby` attribute
4055        pub fn aria_labelled_by_elements(
4056            &mut self,
4057            value: impl Into<std::borrow::Cow<'static, str>>,
4058        ) -> &mut Self {
4059            self.element.set_aria_labelled_by_elements(Some(value.into()));
4060            self
4061        }
4062        /// Set the value of the `aria-level` attribute
4063        pub fn aria_level(&mut self, value: i64) -> &mut Self {
4064            self.element.set_aria_level(Some(value));
4065            self
4066        }
4067        /// Set the value of the `aria-live` attribute
4068        pub fn aria_live(
4069            &mut self,
4070            value: impl Into<std::borrow::Cow<'static, str>>,
4071        ) -> &mut Self {
4072            self.element.set_aria_live(Some(value.into()));
4073            self
4074        }
4075        /// Set the value of the `aria-modal` attribute
4076        pub fn aria_modal(&mut self, value: bool) -> &mut Self {
4077            self.element.set_aria_modal(value);
4078            self
4079        }
4080        /// Set the value of the `aria-multiline` attribute
4081        pub fn aria_multi_line(&mut self, value: bool) -> &mut Self {
4082            self.element.set_aria_multi_line(value);
4083            self
4084        }
4085        /// Set the value of the `aria-multiselectable` attribute
4086        pub fn aria_multi_selectable(&mut self, value: bool) -> &mut Self {
4087            self.element.set_aria_multi_selectable(value);
4088            self
4089        }
4090        /// Set the value of the `aria-orientation` attribute
4091        pub fn aria_orientation(
4092            &mut self,
4093            value: impl Into<std::borrow::Cow<'static, str>>,
4094        ) -> &mut Self {
4095            self.element.set_aria_orientation(Some(value.into()));
4096            self
4097        }
4098        /// Set the value of the `aria-owns` attribute
4099        pub fn aria_owns_elements(
4100            &mut self,
4101            value: impl Into<std::borrow::Cow<'static, str>>,
4102        ) -> &mut Self {
4103            self.element.set_aria_owns_elements(Some(value.into()));
4104            self
4105        }
4106        /// Set the value of the `aria-placeholder` attribute
4107        pub fn aria_placeholder(
4108            &mut self,
4109            value: impl Into<std::borrow::Cow<'static, str>>,
4110        ) -> &mut Self {
4111            self.element.set_aria_placeholder(Some(value.into()));
4112            self
4113        }
4114        /// Set the value of the `aria-posinset` attribute
4115        pub fn aria_pos_in_set(&mut self, value: i64) -> &mut Self {
4116            self.element.set_aria_pos_in_set(Some(value));
4117            self
4118        }
4119        /// Set the value of the `aria-pressed` attribute
4120        pub fn aria_pressed(
4121            &mut self,
4122            value: impl Into<std::borrow::Cow<'static, str>>,
4123        ) -> &mut Self {
4124            self.element.set_aria_pressed(Some(value.into()));
4125            self
4126        }
4127        /// Set the value of the `aria-readonly` attribute
4128        pub fn aria_read_only(&mut self, value: bool) -> &mut Self {
4129            self.element.set_aria_read_only(value);
4130            self
4131        }
4132        /// Set the value of the `aria-relevant` attribute
4133        pub fn aria_relevant(
4134            &mut self,
4135            value: impl Into<std::borrow::Cow<'static, str>>,
4136        ) -> &mut Self {
4137            self.element.set_aria_relevant(Some(value.into()));
4138            self
4139        }
4140        /// Set the value of the `aria-required` attribute
4141        pub fn aria_required(&mut self, value: bool) -> &mut Self {
4142            self.element.set_aria_required(value);
4143            self
4144        }
4145        /// Set the value of the `aria-roledescription` attribute
4146        pub fn aria_role_description(
4147            &mut self,
4148            value: impl Into<std::borrow::Cow<'static, str>>,
4149        ) -> &mut Self {
4150            self.element.set_aria_role_description(Some(value.into()));
4151            self
4152        }
4153        /// Set the value of the `aria-rowcount` attribute
4154        pub fn aria_row_count(&mut self, value: i64) -> &mut Self {
4155            self.element.set_aria_row_count(Some(value));
4156            self
4157        }
4158        /// Set the value of the `aria-rowindex` attribute
4159        pub fn aria_row_index(&mut self, value: i64) -> &mut Self {
4160            self.element.set_aria_row_index(Some(value));
4161            self
4162        }
4163        /// Set the value of the `aria-rowindextext` attribute
4164        pub fn aria_row_index_text(
4165            &mut self,
4166            value: impl Into<std::borrow::Cow<'static, str>>,
4167        ) -> &mut Self {
4168            self.element.set_aria_row_index_text(Some(value.into()));
4169            self
4170        }
4171        /// Set the value of the `aria-rowspan` attribute
4172        pub fn aria_row_span(&mut self, value: i64) -> &mut Self {
4173            self.element.set_aria_row_span(Some(value));
4174            self
4175        }
4176        /// Set the value of the `aria-selected` attribute
4177        pub fn aria_selected(&mut self, value: bool) -> &mut Self {
4178            self.element.set_aria_selected(value);
4179            self
4180        }
4181        /// Set the value of the `aria-setsize` attribute
4182        pub fn aria_set_size(&mut self, value: i64) -> &mut Self {
4183            self.element.set_aria_set_size(Some(value));
4184            self
4185        }
4186        /// Set the value of the `aria-sort` attribute
4187        pub fn aria_sort(
4188            &mut self,
4189            value: impl Into<std::borrow::Cow<'static, str>>,
4190        ) -> &mut Self {
4191            self.element.set_aria_sort(Some(value.into()));
4192            self
4193        }
4194        /// Set the value of the `aria-valuemax` attribute
4195        pub fn aria_value_max(&mut self, value: f64) -> &mut Self {
4196            self.element.set_aria_value_max(Some(value));
4197            self
4198        }
4199        /// Set the value of the `aria-valuemin` attribute
4200        pub fn aria_value_min(&mut self, value: f64) -> &mut Self {
4201            self.element.set_aria_value_min(Some(value));
4202            self
4203        }
4204        /// Set the value of the `aria-valuenow` attribute
4205        pub fn aria_value_now(&mut self, value: f64) -> &mut Self {
4206            self.element.set_aria_value_now(Some(value));
4207            self
4208        }
4209        /// Set the value of the `aria-valuetext` attribute
4210        pub fn aria_value_text(
4211            &mut self,
4212            value: impl Into<std::borrow::Cow<'static, str>>,
4213        ) -> &mut Self {
4214            self.element.set_aria_value_text(Some(value.into()));
4215            self
4216        }
4217        /// Set the value of the `accesskey` attribute
4218        pub fn access_key(
4219            &mut self,
4220            value: impl Into<std::borrow::Cow<'static, str>>,
4221        ) -> &mut Self {
4222            self.element.set_access_key(Some(value.into()));
4223            self
4224        }
4225        /// Set the value of the `autocapitalize` attribute
4226        pub fn auto_capitalize(
4227            &mut self,
4228            value: impl Into<std::borrow::Cow<'static, str>>,
4229        ) -> &mut Self {
4230            self.element.set_auto_capitalize(Some(value.into()));
4231            self
4232        }
4233        /// Set the value of the `autofocus` attribute
4234        pub fn autofocus(&mut self, value: bool) -> &mut Self {
4235            self.element.set_autofocus(value);
4236            self
4237        }
4238        /// Set the value of the `class` attribute
4239        pub fn class(
4240            &mut self,
4241            value: impl Into<std::borrow::Cow<'static, str>>,
4242        ) -> &mut Self {
4243            self.element.set_class(Some(value.into()));
4244            self
4245        }
4246        /// Set the value of the `contenteditable` attribute
4247        pub fn content_editable(
4248            &mut self,
4249            value: impl Into<std::borrow::Cow<'static, str>>,
4250        ) -> &mut Self {
4251            self.element.set_content_editable(Some(value.into()));
4252            self
4253        }
4254        /// Set the value of the `dir` attribute
4255        pub fn direction(
4256            &mut self,
4257            value: impl Into<std::borrow::Cow<'static, str>>,
4258        ) -> &mut Self {
4259            self.element.set_direction(Some(value.into()));
4260            self
4261        }
4262        /// Set the value of the `draggable` attribute
4263        pub fn draggable(&mut self, value: bool) -> &mut Self {
4264            self.element.set_draggable(value);
4265            self
4266        }
4267        /// Set the value of the `enterkeyhint` attribute
4268        pub fn enter_key_hint(
4269            &mut self,
4270            value: impl Into<std::borrow::Cow<'static, str>>,
4271        ) -> &mut Self {
4272            self.element.set_enter_key_hint(Some(value.into()));
4273            self
4274        }
4275        /// Set the value of the `exportparts` attribute
4276        pub fn export_parts(
4277            &mut self,
4278            value: impl Into<std::borrow::Cow<'static, str>>,
4279        ) -> &mut Self {
4280            self.element.set_export_parts(Some(value.into()));
4281            self
4282        }
4283        /// Set the value of the `hidden` attribute
4284        pub fn hidden(
4285            &mut self,
4286            value: impl Into<std::borrow::Cow<'static, str>>,
4287        ) -> &mut Self {
4288            self.element.set_hidden(Some(value.into()));
4289            self
4290        }
4291        /// Set the value of the `id` attribute
4292        pub fn id(
4293            &mut self,
4294            value: impl Into<std::borrow::Cow<'static, str>>,
4295        ) -> &mut Self {
4296            self.element.set_id(Some(value.into()));
4297            self
4298        }
4299        /// Set the value of the `inert` attribute
4300        pub fn inert(&mut self, value: bool) -> &mut Self {
4301            self.element.set_inert(value);
4302            self
4303        }
4304        /// Set the value of the `inputmode` attribute
4305        pub fn input_mode(
4306            &mut self,
4307            value: impl Into<std::borrow::Cow<'static, str>>,
4308        ) -> &mut Self {
4309            self.element.set_input_mode(Some(value.into()));
4310            self
4311        }
4312        /// Set the value of the `is` attribute
4313        pub fn is_(
4314            &mut self,
4315            value: impl Into<std::borrow::Cow<'static, str>>,
4316        ) -> &mut Self {
4317            self.element.set_is_(Some(value.into()));
4318            self
4319        }
4320        /// Set the value of the `itemid` attribute
4321        pub fn item_id(
4322            &mut self,
4323            value: impl Into<std::borrow::Cow<'static, str>>,
4324        ) -> &mut Self {
4325            self.element.set_item_id(Some(value.into()));
4326            self
4327        }
4328        /// Set the value of the `itemprop` attribute
4329        pub fn item_prop(
4330            &mut self,
4331            value: impl Into<std::borrow::Cow<'static, str>>,
4332        ) -> &mut Self {
4333            self.element.set_item_prop(Some(value.into()));
4334            self
4335        }
4336        /// Set the value of the `itemref` attribute
4337        pub fn item_ref(
4338            &mut self,
4339            value: impl Into<std::borrow::Cow<'static, str>>,
4340        ) -> &mut Self {
4341            self.element.set_item_ref(Some(value.into()));
4342            self
4343        }
4344        /// Set the value of the `itemscope` attribute
4345        pub fn item_scope(
4346            &mut self,
4347            value: impl Into<std::borrow::Cow<'static, str>>,
4348        ) -> &mut Self {
4349            self.element.set_item_scope(Some(value.into()));
4350            self
4351        }
4352        /// Set the value of the `itemtype` attribute
4353        pub fn item_type(
4354            &mut self,
4355            value: impl Into<std::borrow::Cow<'static, str>>,
4356        ) -> &mut Self {
4357            self.element.set_item_type(Some(value.into()));
4358            self
4359        }
4360        /// Set the value of the `lang` attribute
4361        pub fn lang(
4362            &mut self,
4363            value: impl Into<std::borrow::Cow<'static, str>>,
4364        ) -> &mut Self {
4365            self.element.set_lang(Some(value.into()));
4366            self
4367        }
4368        /// Set the value of the `nonce` attribute
4369        pub fn nonce(
4370            &mut self,
4371            value: impl Into<std::borrow::Cow<'static, str>>,
4372        ) -> &mut Self {
4373            self.element.set_nonce(Some(value.into()));
4374            self
4375        }
4376        /// Set the value of the `part` attribute
4377        pub fn part(
4378            &mut self,
4379            value: impl Into<std::borrow::Cow<'static, str>>,
4380        ) -> &mut Self {
4381            self.element.set_part(Some(value.into()));
4382            self
4383        }
4384        /// Set the value of the `slot` attribute
4385        pub fn slot_attr(
4386            &mut self,
4387            value: impl Into<std::borrow::Cow<'static, str>>,
4388        ) -> &mut Self {
4389            self.element.set_slot(Some(value.into()));
4390            self
4391        }
4392        /// Set the value of the `spellcheck` attribute
4393        pub fn spellcheck(
4394            &mut self,
4395            value: impl Into<std::borrow::Cow<'static, str>>,
4396        ) -> &mut Self {
4397            self.element.set_spellcheck(Some(value.into()));
4398            self
4399        }
4400        /// Set the value of the `style` attribute
4401        pub fn style_attr(
4402            &mut self,
4403            value: impl Into<std::borrow::Cow<'static, str>>,
4404        ) -> &mut Self {
4405            self.element.set_style(Some(value.into()));
4406            self
4407        }
4408        /// Set the value of the `tabindex` attribute
4409        pub fn tab_index(&mut self, value: i64) -> &mut Self {
4410            self.element.set_tab_index(Some(value));
4411            self
4412        }
4413        /// Set the value of the `title` attribute
4414        pub fn title_attr(
4415            &mut self,
4416            value: impl Into<std::borrow::Cow<'static, str>>,
4417        ) -> &mut Self {
4418            self.element.set_title(Some(value.into()));
4419            self
4420        }
4421        /// Set the value of the `translate` attribute
4422        pub fn translate(&mut self, value: bool) -> &mut Self {
4423            self.element.set_translate(value);
4424            self
4425        }
4426        /// Push a new child element to the list of children.
4427        pub fn push<T>(&mut self, child_el: T) -> &mut Self
4428        where
4429            T: Into<crate::generated::all::children::AnchorChild>,
4430        {
4431            let child_el = child_el.into();
4432            self.element.children_mut().push(child_el);
4433            self
4434        }
4435        /// Extend the list of children with an iterator of child elements.
4436        pub fn extend<I, T>(&mut self, iter: I) -> &mut Self
4437        where
4438            I: IntoIterator<Item = T>,
4439            T: Into<crate::generated::all::children::AnchorChild>,
4440        {
4441            let iter = iter.into_iter().map(|child_el| child_el.into());
4442            self.element.children_mut().extend(iter);
4443            self
4444        }
4445    }
4446}
html/generated/a.rs

html/generated/
a.rs
