Struct a 

pub struct a;

Build a <a> element.

Implementations

impl a

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

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

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

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

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

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

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

Trait Implementations

impl DioxusElement for a

const TAG_NAME: &'static str = "a"

The tag name of the element.

const NAME_SPACE: Option<&'static str> = None

The namespace of the element.

fn tag_name(&self) -> &'static str

The tag name of the element.

fn namespace(&self) -> Option<&'static str>

The namespace of the element.

impl GlobalAttributes for a

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

Prevent the default action for this element.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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<'a>( &self, cx: NodeFactory<'a>, val: Arguments<'_>, ) -> Attribute<'a>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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