Trait patternfly_dioxus::GlobalAttributes

[−]
pub trait GlobalAttributes {

Show 470 methods    fn prevent_default(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn accesskey(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn class(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn contenteditable(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn data(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dir(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn draggable(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn hidden(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn id(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn lang(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn spellcheck(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn style(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn tabindex(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn title(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn translate(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn role(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dangerous_inner_html(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn align_content(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn align_items(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn align_self(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn alignment_adjust(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn alignment_baseline(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn all(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn alt(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn animation(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn animation_delay(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_direction(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_duration(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_fill_mode(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_iteration_count(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_name(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_play_state(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_timing_function(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn azimuth(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn backface_visibility(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn background_attachment(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_clip(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_image(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_origin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_repeat(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_size(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_blend_mode(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn baseline_shift(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bleed(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn bookmark_label(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bookmark_level(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bookmark_state(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn border_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_left(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_left_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_left_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_left_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_right(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_right_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_right_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_right_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn border_top_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_collapse(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_outset(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_repeat(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_slice(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_source(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_radius(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_left_radius(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_right_radius(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_left_radius(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_right_radius(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_spacing(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bottom(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn box_decoration_break(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn box_shadow(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn box_sizing(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn box_snap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn break_after(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn break_before(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn break_inside(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn buffered_rendering(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn caption_side(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn clear(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn clear_side(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn clip(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn clip_path(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn clip_rule(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn color(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn color_adjust(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_correction(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_interpolation(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_interpolation_filters(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_profile(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_rendering(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_fill(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_gap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn column_rule(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_rule_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_rule_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_rule_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_span(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn columns(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn column_count(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn contain(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn content(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn counter_increment(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn counter_reset(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn counter_set(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn cue(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn cue_after(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn cue_before(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn cursor(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn direction(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn display(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn display_inside(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display_outside(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display_extras(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display_box(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn dominant_baseline(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn elevation(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn empty_cells(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn enable_background(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn fill(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fill_opacity(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn fill_rule(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn filter(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn float(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn float_defer_column(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn float_defer_page(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn float_offset(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn float_wrap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flow_into(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flow_from(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flex(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flex_basis(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flex_grow(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flex_shrink(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flex_flow(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flex_direction(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flex_wrap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flood_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flood_opacity(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn font_family(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_size(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn font_stretch(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_style(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn font_weight(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_feature_settings(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_kerning(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_language_override(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_size_adjust(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_synthesis(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_alternates(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_caps(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_east_asian(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_ligatures(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_numeric(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn footnote_policy(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn glyph_orientation_horizontal(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn glyph_orientation_vertical(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn grid_auto_flow(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_auto_columns(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_auto_rows(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_template(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_template_areas(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_template_columns(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_template_rows(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_area(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn grid_column(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_column_start(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_column_end(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_row(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn grid_row_start(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_row_end(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hanging_punctuation(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn height(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn hyphenate_character(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_limit_chars(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_limit_last(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_limit_lines(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_limit_zone(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphens(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn icon(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn image_orientation(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn image_resolution(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn image_rendering(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ime(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ime_align(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ime_mode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ime_offset(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ime_width(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn initial_letters(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn inline_box_align(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn isolation(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn justify_content(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn justify_items(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn justify_self(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn kerning(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn left(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn letter_spacing(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn lighting_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_box_contain(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_break(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn line_grid(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn line_height(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_slack(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn line_snap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn list_style(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn list_style_image(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn list_style_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn list_style_type(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn margin_bottom(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin_left(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin_right(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin_top(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn marker(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn marker_end(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn marker_mid(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn marker_pattern(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_segment(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_start(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_knockout_left(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_knockout_right(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_side(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marks(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn marquee_direction(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marquee_play_count(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marquee_speed(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marquee_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mask_image(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mask_repeat(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_clip(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mask_origin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_size(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mask_box(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mask_box_outset(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_repeat(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_slice(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_source(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_type(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn max_height(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn max_lines(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn max_width(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn min_height(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn min_width(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mix_blend_mode(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn nav_down(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn nav_index(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn nav_left(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn nav_right(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn nav_up(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn object_fit(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn object_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn offset_after(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn offset_before(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn offset_end(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn offset_start(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn opacity(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn order(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn orphans(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn outline(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn outline_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn outline_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn outline_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn outline_offset(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overflow(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn overflow_x(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn overflow_y(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn overflow_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overflow_wrap(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn padding_bottom(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding_left(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding_right(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding_top(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn page(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn page_break_after(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn page_break_before(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn page_break_inside(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn paint_order(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pause(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pause_after(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pause_before(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn perspective(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn perspective_origin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pitch(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pitch_range(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn play_during(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pointer_events(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn position(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn quotes(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn region_fragment(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn resize(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rest(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rest_after(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rest_before(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn richness(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn right(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ruby_align(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ruby_merge(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ruby_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_behavior(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_coordinate(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_destination(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_points_x(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_points_y(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_type(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_image_threshold(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_inside(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_margin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_outside(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_padding(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_rendering(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn size(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn speak(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn speak_as(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn speak_header(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speak_numeral(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speak_punctuation(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speech_rate(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stop_color(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn stop_opacity(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stress(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn string_set(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn stroke(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn stroke_dasharray(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_dashoffset(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_linecap(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_linejoin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_miterlimit(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_opacity(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_width(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn tab_size(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn table_layout(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_align(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn text_align_all(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_align_last(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_anchor(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_combine_upright(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration_line(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration_skip(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis_color(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis_skip(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_height(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_indent(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_justify(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_orientation(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_overflow(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_rendering(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_shadow(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_size_adjust(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_space_collapse(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_spacing(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_transform(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_underline_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_wrap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn top(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn touch_action(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transform(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn transform_box(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transform_origin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transform_style(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transition(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn transition_delay(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transition_duration(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transition_property(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn unicode_bidi(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vector_effect(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vertical_align(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn visibility(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn voice_balance(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_duration(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_family(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_pitch(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_range(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_rate(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn voice_stress(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_volumn(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn volume(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn white_space(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn widows(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn width(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn will_change(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn word_break(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn word_spacing(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn word_wrap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn wrap_flow(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn wrap_through(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn writing_mode(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn gap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn list_styler_type(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn row_gap(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn transition_timing_function(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn user_select(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn webkit_user_select(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn z_index(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn aria_current(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_details(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_disabled(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_hidden(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_invalid(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_keyshortcuts(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_label(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn aria_roledescription(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_autocomplete(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_checked(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_expanded(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_haspopup(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_level(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn aria_modal(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn aria_multiline(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_multiselectable(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_orientation(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_placeholder(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_pressed(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_readonly(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_required(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_selected(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_sort(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn aria_valuemax(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_valuemin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_valuenow(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_valuetext(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_atomic(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_busy(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn aria_live(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn aria_relevant(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_dropeffect(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_grabbed(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_activedescendant(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_colcount(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_colindex(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_colspan(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_controls(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_describedby(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_errormessage(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_flowto(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_labelledby(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_owns(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn aria_posinset(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_rowcount(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_rowindex(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_rowspan(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_setsize(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

}

Provided Methods

Prevent the default action for this element.

For more information, see the MDN docs: https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault

The HTML class attribute is used to specify a class for an HTML element.

Details

Multiple HTML elements can share the same class.

The class global attribute is a space-separated list of the case-sensitive classes of the element. Classes allow CSS and Javascript to select and access specific elements via the class selectors or functions like the DOM method document.getElementsByClassName.

Example
HTML:
<p class="note editorial">Above point sounds a bit obvious. Remove/rewrite?</p>
CSS:
.note {
    font-style: italic;
    font-weight: bold;
}

.editorial {
    background: rgb(255, 0, 0, .25);
    padding: 10px;
}

dangerous_inner_html is Dioxus’s replacement for using innerHTML in the browser DOM. In general, setting HTML from code is risky because it’s easy to inadvertently expose your users to a cross-site scripting (XSS) attack. So, you can set HTML directly from Dioxus, but you have to type out dangerous_inner_html to remind yourself that it’s dangerous

fn align_content(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a>

fn float_defer_page(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

fn justify_content(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

Implementors

impl GlobalAttributes for article

impl GlobalAttributes for body