Struct dioxus_html::circle

pub struct circle;

Build a <circle> element.

Trait Implementations

impl DioxusElement for circle

const TAG_NAME: &'static str

The tag name of the element.

const NAME_SPACE: Option<&'static str>

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 SvgAttributes for circle

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

Prevent the default action for this element.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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