Trait patternfly_dioxus::SvgAttributes

pub trait SvgAttributes {
    fn prevent_default(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn accent_height(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn accumulate(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn additive(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn alignment_baseline(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn alphabetic(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn amplitude(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn arabic_form(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ascent(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn attributeName(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn attributeType(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn azimuth(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn baseFrequency(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn baseline_shift(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn baseProfile(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bbox(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn begin(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn bias(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn by(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn calcMode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn cap_height(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn class(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn clip(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn clipPathUnits(
        &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_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 contentScriptType(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn contentStyleType(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn crossorigin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn cursor(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn cx(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn cy(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn d(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn decelerate(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn descent(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn diffuseConstant(
        &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 divisor(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dominant_baseline(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn dur(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dx(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dy(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn edgeMode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn elevation(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn enable_background(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn end(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn exponent(&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 filterRes(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn filterUnits(
        &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_family(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_size(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn font_size_adjust(
        &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_variant(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_weight(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn format(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn from(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fr(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fx(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fy(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn g1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn g2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn glyph_name(&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 glyphRef(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn gradientTransform(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn gradientUnits(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hanging(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn height(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn href(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn hreflang(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn horiz_adv_x(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn horiz_origin_x(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn id(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ideographic(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn image_rendering(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn _in(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn in2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn intercept(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k3(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn k4(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn kernelMatrix(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn kernelUnitLength(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn kerning(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn keyPoints(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn keySplines(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn keyTimes(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn lang(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn lengthAdjust(
        &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 limitingConeAngle(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn local(&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_start(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn markerHeight(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn markerUnits(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn markerWidth(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn maskContentUnits(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn maskUnits(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mathematical(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn max(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn media(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn method(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn min(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn name(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn numOctaves(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn offset(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn opacity(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn operator(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn order(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn orient(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn orientation(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn origin(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn overflow(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn overline_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overline_thickness(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn panose_1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn paint_order(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn path(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pathLength(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn patternContentUnits(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn patternTransform(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn patternUnits(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ping(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pointer_events(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn points(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pointsAtX(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pointsAtY(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn pointsAtZ(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn preserveAlpha(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn preserveAspectRatio(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn primitiveUnits(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn r(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn radius(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn referrerPolicy(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn refX(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn refY(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rel(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rendering_intent(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn repeatCount(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn repeatDur(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn requiredExtensions(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn requiredFeatures(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn restart(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn result(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn role(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rotate(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rx(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ry(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn scale(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn seed(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn shape_rendering(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn slope(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn spacing(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn specularConstant(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn specularExponent(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speed(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn spreadMethod(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn startOffset(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stdDeviation(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stemh(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn stemv(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn stitchTiles(
        &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 strikethrough_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn strikethrough_thickness(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn string(&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 style(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn surfaceScale(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn systemLanguage(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn tabindex(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn tableValues(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn target(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn targetX(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn targetY(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn text_anchor(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_rendering(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn textLength(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn to(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn transform(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn transform_origin(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn type(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn u1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn u2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn underline_position(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn underline_thickness(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn unicode(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn unicode_bidi(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn unicode_range(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn units_per_em(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn v_alphabetic(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn v_hanging(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn v_ideographic(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn v_mathematical(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn values(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn vector_effect(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn version(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn vert_adv_y(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn vert_origin_x(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vert_origin_y(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn view_box(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn view_target(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn visibility(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn width(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn widths(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn word_spacing(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn writing_mode(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn x(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn x_height(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn x1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn x2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn xmlns(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn x_channel_selector(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn y(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn y1(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn y2(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn y_channel_selector(
        &self,
        cx: NodeFactory<'a>,
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn z(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn zoomAndPan(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
}

Provided Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementors

impl SvgAttributes for animate

impl SvgAttributes for animateMotion

impl SvgAttributes for animateTransform

impl SvgAttributes for circle

impl SvgAttributes for clipPath

impl SvgAttributes for defs

impl SvgAttributes for desc

impl SvgAttributes for discard

impl SvgAttributes for ellipse

impl SvgAttributes for feBlend

impl SvgAttributes for feColorMatrix

impl SvgAttributes for feComponentTransfer

impl SvgAttributes for feComposite

impl SvgAttributes for feConvolveMatrix

impl SvgAttributes for feDiffuseLighting

impl SvgAttributes for feDisplacementMap

impl SvgAttributes for feDistantLight

impl SvgAttributes for feDropShadow

impl SvgAttributes for feFlood

impl SvgAttributes for feFuncA

impl SvgAttributes for feFuncB

impl SvgAttributes for feFuncG

impl SvgAttributes for feFuncR

impl SvgAttributes for feGaussianBlur

impl SvgAttributes for feImage

impl SvgAttributes for feMerge

impl SvgAttributes for feMergeNode

impl SvgAttributes for feMorphology

impl SvgAttributes for feOffset

impl SvgAttributes for fePointLight

impl SvgAttributes for feSpecularLighting

impl SvgAttributes for feSpotLight

impl SvgAttributes for feTile

impl SvgAttributes for feTurbulence

impl SvgAttributes for filter

impl SvgAttributes for foreignObject

impl SvgAttributes for g

impl SvgAttributes for hatch

impl SvgAttributes for hatchpath

impl SvgAttributes for line

impl SvgAttributes for linearGradient

impl SvgAttributes for marker

impl SvgAttributes for mask

impl SvgAttributes for metadata

impl SvgAttributes for mpath

impl SvgAttributes for path

impl SvgAttributes for pattern

impl SvgAttributes for polygon

impl SvgAttributes for polyline

impl SvgAttributes for radialGradient

impl SvgAttributes for rect

impl SvgAttributes for set

impl SvgAttributes for stop

impl SvgAttributes for svg

impl SvgAttributes for switch

impl SvgAttributes for symbol

impl SvgAttributes for text

impl SvgAttributes for textPath

impl SvgAttributes for tspan

impl SvgAttributes for view