diff --git a/Userland/Libraries/LibWeb/CSS/StyleValue.cpp b/Userland/Libraries/LibWeb/CSS/StyleValue.cpp
index 73c3e4c8cec..4c6fc69f72c 100644
--- a/Userland/Libraries/LibWeb/CSS/StyleValue.cpp
+++ b/Userland/Libraries/LibWeb/CSS/StyleValue.cpp
@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
+ * Copyright (c) 2021-2024, Sam Atkins <sam@ladybird.org>
  * Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
  * Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
  *
@@ -74,14 +74,299 @@ AbstractImageStyleValue const& StyleValue::as_abstract_image() const
     return static_cast<AbstractImageStyleValue const&>(*this);
 }
 
-#define __ENUMERATE_STYLE_VALUE_TYPE(TitleCaseName, SnakeCaseName)          \
-    TitleCaseName##StyleValue const& StyleValue::as_##SnakeCaseName() const \
-    {                                                                       \
-        VERIFY(is_##SnakeCaseName());                                       \
-        return static_cast<TitleCaseName##StyleValue const&>(*this);        \
-    }
-ENUMERATE_STYLE_VALUE_TYPES
-#undef __ENUMERATE_STYLE_VALUE_TYPE
+AngleStyleValue const& StyleValue::as_angle() const
+{
+    VERIFY(is_angle());
+    return static_cast<AngleStyleValue const&>(*this);
+}
+
+BackgroundRepeatStyleValue const& StyleValue::as_background_repeat() const
+{
+    VERIFY(is_background_repeat());
+    return static_cast<BackgroundRepeatStyleValue const&>(*this);
+}
+
+BackgroundSizeStyleValue const& StyleValue::as_background_size() const
+{
+    VERIFY(is_background_size());
+    return static_cast<BackgroundSizeStyleValue const&>(*this);
+}
+
+BasicShapeStyleValue const& StyleValue::as_basic_shape() const
+{
+    VERIFY(is_basic_shape());
+    return static_cast<BasicShapeStyleValue const&>(*this);
+}
+
+BorderRadiusStyleValue const& StyleValue::as_border_radius() const
+{
+    VERIFY(is_border_radius());
+    return static_cast<BorderRadiusStyleValue const&>(*this);
+}
+
+CalculatedStyleValue const& StyleValue::as_calculated() const
+{
+    VERIFY(is_calculated());
+    return static_cast<CalculatedStyleValue const&>(*this);
+}
+
+ColorStyleValue const& StyleValue::as_color() const
+{
+    VERIFY(is_color());
+    return static_cast<ColorStyleValue const&>(*this);
+}
+
+ConicGradientStyleValue const& StyleValue::as_conic_gradient() const
+{
+    VERIFY(is_conic_gradient());
+    return static_cast<ConicGradientStyleValue const&>(*this);
+}
+
+ContentStyleValue const& StyleValue::as_content() const
+{
+    VERIFY(is_content());
+    return static_cast<ContentStyleValue const&>(*this);
+}
+
+CounterStyleValue const& StyleValue::as_counter() const
+{
+    VERIFY(is_counter());
+    return static_cast<CounterStyleValue const&>(*this);
+}
+
+CounterDefinitionsStyleValue const& StyleValue::as_counter_definitions() const
+{
+    VERIFY(is_counter_definitions());
+    return static_cast<CounterDefinitionsStyleValue const&>(*this);
+}
+
+CustomIdentStyleValue const& StyleValue::as_custom_ident() const
+{
+    VERIFY(is_custom_ident());
+    return static_cast<CustomIdentStyleValue const&>(*this);
+}
+
+DisplayStyleValue const& StyleValue::as_display() const
+{
+    VERIFY(is_display());
+    return static_cast<DisplayStyleValue const&>(*this);
+}
+
+EasingStyleValue const& StyleValue::as_easing() const
+{
+    VERIFY(is_easing());
+    return static_cast<EasingStyleValue const&>(*this);
+}
+
+EdgeStyleValue const& StyleValue::as_edge() const
+{
+    VERIFY(is_edge());
+    return static_cast<EdgeStyleValue const&>(*this);
+}
+
+FilterValueListStyleValue const& StyleValue::as_filter_value_list() const
+{
+    VERIFY(is_filter_value_list());
+    return static_cast<FilterValueListStyleValue const&>(*this);
+}
+
+FlexStyleValue const& StyleValue::as_flex() const
+{
+    VERIFY(is_flex());
+    return static_cast<FlexStyleValue const&>(*this);
+}
+
+FrequencyStyleValue const& StyleValue::as_frequency() const
+{
+    VERIFY(is_frequency());
+    return static_cast<FrequencyStyleValue const&>(*this);
+}
+
+GridAutoFlowStyleValue const& StyleValue::as_grid_auto_flow() const
+{
+    VERIFY(is_grid_auto_flow());
+    return static_cast<GridAutoFlowStyleValue const&>(*this);
+}
+
+GridTemplateAreaStyleValue const& StyleValue::as_grid_template_area() const
+{
+    VERIFY(is_grid_template_area());
+    return static_cast<GridTemplateAreaStyleValue const&>(*this);
+}
+
+GridTrackPlacementStyleValue const& StyleValue::as_grid_track_placement() const
+{
+    VERIFY(is_grid_track_placement());
+    return static_cast<GridTrackPlacementStyleValue const&>(*this);
+}
+
+GridTrackSizeListStyleValue const& StyleValue::as_grid_track_size_list() const
+{
+    VERIFY(is_grid_track_size_list());
+    return static_cast<GridTrackSizeListStyleValue const&>(*this);
+}
+
+IdentifierStyleValue const& StyleValue::as_identifier() const
+{
+    VERIFY(is_identifier());
+    return static_cast<IdentifierStyleValue const&>(*this);
+}
+
+ImageStyleValue const& StyleValue::as_image() const
+{
+    VERIFY(is_image());
+    return static_cast<ImageStyleValue const&>(*this);
+}
+
+InheritStyleValue const& StyleValue::as_inherit() const
+{
+    VERIFY(is_inherit());
+    return static_cast<InheritStyleValue const&>(*this);
+}
+
+InitialStyleValue const& StyleValue::as_initial() const
+{
+    VERIFY(is_initial());
+    return static_cast<InitialStyleValue const&>(*this);
+}
+
+IntegerStyleValue const& StyleValue::as_integer() const
+{
+    VERIFY(is_integer());
+    return static_cast<IntegerStyleValue const&>(*this);
+}
+
+LengthStyleValue const& StyleValue::as_length() const
+{
+    VERIFY(is_length());
+    return static_cast<LengthStyleValue const&>(*this);
+}
+
+LinearGradientStyleValue const& StyleValue::as_linear_gradient() const
+{
+    VERIFY(is_linear_gradient());
+    return static_cast<LinearGradientStyleValue const&>(*this);
+}
+
+MathDepthStyleValue const& StyleValue::as_math_depth() const
+{
+    VERIFY(is_math_depth());
+    return static_cast<MathDepthStyleValue const&>(*this);
+}
+
+NumberStyleValue const& StyleValue::as_number() const
+{
+    VERIFY(is_number());
+    return static_cast<NumberStyleValue const&>(*this);
+}
+
+PercentageStyleValue const& StyleValue::as_percentage() const
+{
+    VERIFY(is_percentage());
+    return static_cast<PercentageStyleValue const&>(*this);
+}
+
+PositionStyleValue const& StyleValue::as_position() const
+{
+    VERIFY(is_position());
+    return static_cast<PositionStyleValue const&>(*this);
+}
+
+RadialGradientStyleValue const& StyleValue::as_radial_gradient() const
+{
+    VERIFY(is_radial_gradient());
+    return static_cast<RadialGradientStyleValue const&>(*this);
+}
+
+RatioStyleValue const& StyleValue::as_ratio() const
+{
+    VERIFY(is_ratio());
+    return static_cast<RatioStyleValue const&>(*this);
+}
+
+RectStyleValue const& StyleValue::as_rect() const
+{
+    VERIFY(is_rect());
+    return static_cast<RectStyleValue const&>(*this);
+}
+
+ResolutionStyleValue const& StyleValue::as_resolution() const
+{
+    VERIFY(is_resolution());
+    return static_cast<ResolutionStyleValue const&>(*this);
+}
+
+RevertStyleValue const& StyleValue::as_revert() const
+{
+    VERIFY(is_revert());
+    return static_cast<RevertStyleValue const&>(*this);
+}
+
+ScrollbarGutterStyleValue const& StyleValue::as_scrollbar_gutter() const
+{
+    VERIFY(is_scrollbar_gutter());
+    return static_cast<ScrollbarGutterStyleValue const&>(*this);
+}
+
+ShadowStyleValue const& StyleValue::as_shadow() const
+{
+    VERIFY(is_shadow());
+    return static_cast<ShadowStyleValue const&>(*this);
+}
+
+ShorthandStyleValue const& StyleValue::as_shorthand() const
+{
+    VERIFY(is_shorthand());
+    return static_cast<ShorthandStyleValue const&>(*this);
+}
+
+StringStyleValue const& StyleValue::as_string() const
+{
+    VERIFY(is_string());
+    return static_cast<StringStyleValue const&>(*this);
+}
+
+TimeStyleValue const& StyleValue::as_time() const
+{
+    VERIFY(is_time());
+    return static_cast<TimeStyleValue const&>(*this);
+}
+
+TransformationStyleValue const& StyleValue::as_transformation() const
+{
+    VERIFY(is_transformation());
+    return static_cast<TransformationStyleValue const&>(*this);
+}
+
+TransitionStyleValue const& StyleValue::as_transition() const
+{
+    VERIFY(is_transition());
+    return static_cast<TransitionStyleValue const&>(*this);
+}
+
+UnresolvedStyleValue const& StyleValue::as_unresolved() const
+{
+    VERIFY(is_unresolved());
+    return static_cast<UnresolvedStyleValue const&>(*this);
+}
+
+UnsetStyleValue const& StyleValue::as_unset() const
+{
+    VERIFY(is_unset());
+    return static_cast<UnsetStyleValue const&>(*this);
+}
+
+URLStyleValue const& StyleValue::as_url() const
+{
+    VERIFY(is_url());
+    return static_cast<URLStyleValue const&>(*this);
+}
+
+StyleValueList const& StyleValue::as_value_list() const
+{
+    VERIFY(is_value_list());
+    return static_cast<StyleValueList const&>(*this);
+}
 
 ValueComparingNonnullRefPtr<StyleValue const> StyleValue::absolutized(CSSPixelRect const&, Length::FontMetrics const&, Length::FontMetrics const&) const
 {
diff --git a/Userland/Libraries/LibWeb/CSS/StyleValue.h b/Userland/Libraries/LibWeb/CSS/StyleValue.h
index e0967213645..42821558faf 100644
--- a/Userland/Libraries/LibWeb/CSS/StyleValue.h
+++ b/Userland/Libraries/LibWeb/CSS/StyleValue.h
@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
  * Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
- * Copyright (c) 2021-2023, Sam Atkins <atkinssj@serenityos.org>
+ * Copyright (c) 2021-2024, Sam Atkins <sam@ladybird.org>
  * Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
  *
  * SPDX-License-Identifier: BSD-2-Clause
@@ -82,80 +82,64 @@ private:
 
 using StyleValueVector = Vector<ValueComparingNonnullRefPtr<StyleValue const>>;
 
-#define ENUMERATE_STYLE_VALUE_TYPES                                        \
-    __ENUMERATE_STYLE_VALUE_TYPE(Angle, angle)                             \
-    __ENUMERATE_STYLE_VALUE_TYPE(BackgroundRepeat, background_repeat)      \
-    __ENUMERATE_STYLE_VALUE_TYPE(BackgroundSize, background_size)          \
-    __ENUMERATE_STYLE_VALUE_TYPE(BasicShape, basic_shape)                  \
-    __ENUMERATE_STYLE_VALUE_TYPE(BorderRadius, border_radius)              \
-    __ENUMERATE_STYLE_VALUE_TYPE(Calculated, calculated)                   \
-    __ENUMERATE_STYLE_VALUE_TYPE(Color, color)                             \
-    __ENUMERATE_STYLE_VALUE_TYPE(ConicGradient, conic_gradient)            \
-    __ENUMERATE_STYLE_VALUE_TYPE(Content, content)                         \
-    __ENUMERATE_STYLE_VALUE_TYPE(Counter, counter)                         \
-    __ENUMERATE_STYLE_VALUE_TYPE(CounterDefinitions, counter_definitions)  \
-    __ENUMERATE_STYLE_VALUE_TYPE(CustomIdent, custom_ident)                \
-    __ENUMERATE_STYLE_VALUE_TYPE(Display, display)                         \
-    __ENUMERATE_STYLE_VALUE_TYPE(Easing, easing)                           \
-    __ENUMERATE_STYLE_VALUE_TYPE(Edge, edge)                               \
-    __ENUMERATE_STYLE_VALUE_TYPE(FilterValueList, filter_value_list)       \
-    __ENUMERATE_STYLE_VALUE_TYPE(Flex, flex)                               \
-    __ENUMERATE_STYLE_VALUE_TYPE(Frequency, frequency)                     \
-    __ENUMERATE_STYLE_VALUE_TYPE(GridAutoFlow, grid_auto_flow)             \
-    __ENUMERATE_STYLE_VALUE_TYPE(GridTemplateArea, grid_template_area)     \
-    __ENUMERATE_STYLE_VALUE_TYPE(GridTrackPlacement, grid_track_placement) \
-    __ENUMERATE_STYLE_VALUE_TYPE(GridTrackSizeList, grid_track_size_list)  \
-    __ENUMERATE_STYLE_VALUE_TYPE(Identifier, identifier)                   \
-    __ENUMERATE_STYLE_VALUE_TYPE(Image, image)                             \
-    __ENUMERATE_STYLE_VALUE_TYPE(Inherit, inherit)                         \
-    __ENUMERATE_STYLE_VALUE_TYPE(Initial, initial)                         \
-    __ENUMERATE_STYLE_VALUE_TYPE(Integer, integer)                         \
-    __ENUMERATE_STYLE_VALUE_TYPE(Length, length)                           \
-    __ENUMERATE_STYLE_VALUE_TYPE(LinearGradient, linear_gradient)          \
-    __ENUMERATE_STYLE_VALUE_TYPE(MathDepth, math_depth)                    \
-    __ENUMERATE_STYLE_VALUE_TYPE(Number, number)                           \
-    __ENUMERATE_STYLE_VALUE_TYPE(Percentage, percentage)                   \
-    __ENUMERATE_STYLE_VALUE_TYPE(Position, position)                       \
-    __ENUMERATE_STYLE_VALUE_TYPE(RadialGradient, radial_gradient)          \
-    __ENUMERATE_STYLE_VALUE_TYPE(Ratio, ratio)                             \
-    __ENUMERATE_STYLE_VALUE_TYPE(Rect, rect)                               \
-    __ENUMERATE_STYLE_VALUE_TYPE(Resolution, resolution)                   \
-    __ENUMERATE_STYLE_VALUE_TYPE(Revert, revert)                           \
-    __ENUMERATE_STYLE_VALUE_TYPE(ScrollbarGutter, scrollbar_gutter)        \
-    __ENUMERATE_STYLE_VALUE_TYPE(Shadow, shadow)                           \
-    __ENUMERATE_STYLE_VALUE_TYPE(Shorthand, shorthand)                     \
-    __ENUMERATE_STYLE_VALUE_TYPE(String, string)                           \
-    __ENUMERATE_STYLE_VALUE_TYPE(Time, time)                               \
-    __ENUMERATE_STYLE_VALUE_TYPE(Transformation, transformation)           \
-    __ENUMERATE_STYLE_VALUE_TYPE(Transition, transition)                   \
-    __ENUMERATE_STYLE_VALUE_TYPE(Unresolved, unresolved)                   \
-    __ENUMERATE_STYLE_VALUE_TYPE(Unset, unset)                             \
-    __ENUMERATE_STYLE_VALUE_TYPE(URL, url)                                 \
-    __ENUMERATE_STYLE_VALUE_TYPE(ValueList, value_list)
-
-// NOTE:
-using ValueListStyleValue = StyleValueList;
-
 class StyleValue : public RefCounted<StyleValue> {
 public:
     virtual ~StyleValue() = default;
 
     enum class Type {
-#define __ENUMERATE_STYLE_VALUE_TYPE(TitleCaseName, SnakeCaseName) \
-    TitleCaseName,
-        ENUMERATE_STYLE_VALUE_TYPES
-#undef __ENUMERATE_STYLE_VALUE_TYPE
+        Angle,
+        BackgroundRepeat,
+        BackgroundSize,
+        BasicShape,
+        BorderRadius,
+        Calculated,
+        Color,
+        ConicGradient,
+        Content,
+        Counter,
+        CounterDefinitions,
+        CustomIdent,
+        Display,
+        Easing,
+        Edge,
+        FilterValueList,
+        Flex,
+        Frequency,
+        GridAutoFlow,
+        GridTemplateArea,
+        GridTrackPlacement,
+        GridTrackSizeList,
+        Identifier,
+        Image,
+        Inherit,
+        Initial,
+        Integer,
+        Length,
+        LinearGradient,
+        MathDepth,
+        Number,
+        Percentage,
+        Position,
+        RadialGradient,
+        Ratio,
+        Rect,
+        Resolution,
+        Revert,
+        ScrollbarGutter,
+        Shadow,
+        Shorthand,
+        String,
+        Time,
+        Transformation,
+        Transition,
+        Unresolved,
+        Unset,
+        URL,
+        ValueList,
     };
 
     Type type() const { return m_type; }
 
-#define __ENUMERATE_STYLE_VALUE_TYPE(TitleCaseName, SnakeCaseName)            \
-    bool is_##SnakeCaseName() const { return type() == Type::TitleCaseName; } \
-    TitleCaseName##StyleValue const& as_##SnakeCaseName() const;              \
-    TitleCaseName##StyleValue& as_##SnakeCaseName() { return const_cast<TitleCaseName##StyleValue&>(const_cast<StyleValue const&>(*this).as_##SnakeCaseName()); }
-    ENUMERATE_STYLE_VALUE_TYPES
-#undef __ENUMERATE_STYLE_VALUE_TYPE
-
     bool is_abstract_image() const
     {
         return AK::first_is_one_of(type(), Type::Image, Type::LinearGradient, Type::ConicGradient, Type::RadialGradient);
@@ -163,6 +147,202 @@ public:
     AbstractImageStyleValue const& as_abstract_image() const;
     AbstractImageStyleValue& as_abstract_image() { return const_cast<AbstractImageStyleValue&>(const_cast<StyleValue const&>(*this).as_abstract_image()); }
 
+    bool is_angle() const { return type() == Type::Angle; }
+    AngleStyleValue const& as_angle() const;
+    AngleStyleValue& as_angle() { return const_cast<AngleStyleValue&>(const_cast<StyleValue const&>(*this).as_angle()); }
+
+    bool is_background_repeat() const { return type() == Type::BackgroundRepeat; }
+    BackgroundRepeatStyleValue const& as_background_repeat() const;
+    BackgroundRepeatStyleValue& as_background_repeat() { return const_cast<BackgroundRepeatStyleValue&>(const_cast<StyleValue const&>(*this).as_background_repeat()); }
+
+    bool is_background_size() const { return type() == Type::BackgroundSize; }
+    BackgroundSizeStyleValue const& as_background_size() const;
+    BackgroundSizeStyleValue& as_background_size() { return const_cast<BackgroundSizeStyleValue&>(const_cast<StyleValue const&>(*this).as_background_size()); }
+
+    bool is_basic_shape() const { return type() == Type::BasicShape; }
+    BasicShapeStyleValue const& as_basic_shape() const;
+    BasicShapeStyleValue& as_basic_shape() { return const_cast<BasicShapeStyleValue&>(const_cast<StyleValue const&>(*this).as_basic_shape()); }
+
+    bool is_border_radius() const { return type() == Type::BorderRadius; }
+    BorderRadiusStyleValue const& as_border_radius() const;
+    BorderRadiusStyleValue& as_border_radius() { return const_cast<BorderRadiusStyleValue&>(const_cast<StyleValue const&>(*this).as_border_radius()); }
+
+    bool is_calculated() const { return type() == Type::Calculated; }
+    CalculatedStyleValue const& as_calculated() const;
+    CalculatedStyleValue& as_calculated() { return const_cast<CalculatedStyleValue&>(const_cast<StyleValue const&>(*this).as_calculated()); }
+
+    bool is_color() const { return type() == Type::Color; }
+    ColorStyleValue const& as_color() const;
+    ColorStyleValue& as_color() { return const_cast<ColorStyleValue&>(const_cast<StyleValue const&>(*this).as_color()); }
+
+    bool is_conic_gradient() const { return type() == Type::ConicGradient; }
+    ConicGradientStyleValue const& as_conic_gradient() const;
+    ConicGradientStyleValue& as_conic_gradient() { return const_cast<ConicGradientStyleValue&>(const_cast<StyleValue const&>(*this).as_conic_gradient()); }
+
+    bool is_content() const { return type() == Type::Content; }
+    ContentStyleValue const& as_content() const;
+    ContentStyleValue& as_content() { return const_cast<ContentStyleValue&>(const_cast<StyleValue const&>(*this).as_content()); }
+
+    bool is_counter() const { return type() == Type::Counter; }
+    CounterStyleValue const& as_counter() const;
+    CounterStyleValue& as_counter() { return const_cast<CounterStyleValue&>(const_cast<StyleValue const&>(*this).as_counter()); }
+
+    bool is_counter_definitions() const { return type() == Type::CounterDefinitions; }
+    CounterDefinitionsStyleValue const& as_counter_definitions() const;
+    CounterDefinitionsStyleValue& as_counter_definitions() { return const_cast<CounterDefinitionsStyleValue&>(const_cast<StyleValue const&>(*this).as_counter_definitions()); }
+
+    bool is_custom_ident() const { return type() == Type::CustomIdent; }
+    CustomIdentStyleValue const& as_custom_ident() const;
+    CustomIdentStyleValue& as_custom_ident() { return const_cast<CustomIdentStyleValue&>(const_cast<StyleValue const&>(*this).as_custom_ident()); }
+
+    bool is_display() const { return type() == Type::Display; }
+    DisplayStyleValue const& as_display() const;
+    DisplayStyleValue& as_display() { return const_cast<DisplayStyleValue&>(const_cast<StyleValue const&>(*this).as_display()); }
+
+    bool is_easing() const { return type() == Type::Easing; }
+    EasingStyleValue const& as_easing() const;
+    EasingStyleValue& as_easing() { return const_cast<EasingStyleValue&>(const_cast<StyleValue const&>(*this).as_easing()); }
+
+    bool is_edge() const { return type() == Type::Edge; }
+    EdgeStyleValue const& as_edge() const;
+    EdgeStyleValue& as_edge() { return const_cast<EdgeStyleValue&>(const_cast<StyleValue const&>(*this).as_edge()); }
+
+    bool is_filter_value_list() const { return type() == Type::FilterValueList; }
+    FilterValueListStyleValue const& as_filter_value_list() const;
+    FilterValueListStyleValue& as_filter_value_list() { return const_cast<FilterValueListStyleValue&>(const_cast<StyleValue const&>(*this).as_filter_value_list()); }
+
+    bool is_flex() const { return type() == Type::Flex; }
+    FlexStyleValue const& as_flex() const;
+    FlexStyleValue& as_flex() { return const_cast<FlexStyleValue&>(const_cast<StyleValue const&>(*this).as_flex()); }
+
+    bool is_frequency() const { return type() == Type::Frequency; }
+    FrequencyStyleValue const& as_frequency() const;
+    FrequencyStyleValue& as_frequency() { return const_cast<FrequencyStyleValue&>(const_cast<StyleValue const&>(*this).as_frequency()); }
+
+    bool is_grid_auto_flow() const { return type() == Type::GridAutoFlow; }
+    GridAutoFlowStyleValue const& as_grid_auto_flow() const;
+    GridAutoFlowStyleValue& as_grid_auto_flow() { return const_cast<GridAutoFlowStyleValue&>(const_cast<StyleValue const&>(*this).as_grid_auto_flow()); }
+
+    bool is_grid_template_area() const { return type() == Type::GridTemplateArea; }
+    GridTemplateAreaStyleValue const& as_grid_template_area() const;
+    GridTemplateAreaStyleValue& as_grid_template_area() { return const_cast<GridTemplateAreaStyleValue&>(const_cast<StyleValue const&>(*this).as_grid_template_area()); }
+
+    bool is_grid_track_placement() const { return type() == Type::GridTrackPlacement; }
+    GridTrackPlacementStyleValue const& as_grid_track_placement() const;
+    GridTrackPlacementStyleValue& as_grid_track_placement() { return const_cast<GridTrackPlacementStyleValue&>(const_cast<StyleValue const&>(*this).as_grid_track_placement()); }
+
+    bool is_grid_track_size_list() const { return type() == Type::GridTrackSizeList; }
+    GridTrackSizeListStyleValue const& as_grid_track_size_list() const;
+    GridTrackSizeListStyleValue& as_grid_track_size_list() { return const_cast<GridTrackSizeListStyleValue&>(const_cast<StyleValue const&>(*this).as_grid_track_size_list()); }
+
+    bool is_identifier() const { return type() == Type::Identifier; }
+    IdentifierStyleValue const& as_identifier() const;
+    IdentifierStyleValue& as_identifier() { return const_cast<IdentifierStyleValue&>(const_cast<StyleValue const&>(*this).as_identifier()); }
+
+    bool is_image() const { return type() == Type::Image; }
+    ImageStyleValue const& as_image() const;
+    ImageStyleValue& as_image() { return const_cast<ImageStyleValue&>(const_cast<StyleValue const&>(*this).as_image()); }
+
+    bool is_inherit() const { return type() == Type::Inherit; }
+    InheritStyleValue const& as_inherit() const;
+    InheritStyleValue& as_inherit() { return const_cast<InheritStyleValue&>(const_cast<StyleValue const&>(*this).as_inherit()); }
+
+    bool is_initial() const { return type() == Type::Initial; }
+    InitialStyleValue const& as_initial() const;
+    InitialStyleValue& as_initial() { return const_cast<InitialStyleValue&>(const_cast<StyleValue const&>(*this).as_initial()); }
+
+    bool is_integer() const { return type() == Type::Integer; }
+    IntegerStyleValue const& as_integer() const;
+    IntegerStyleValue& as_integer() { return const_cast<IntegerStyleValue&>(const_cast<StyleValue const&>(*this).as_integer()); }
+
+    bool is_length() const { return type() == Type::Length; }
+    LengthStyleValue const& as_length() const;
+    LengthStyleValue& as_length() { return const_cast<LengthStyleValue&>(const_cast<StyleValue const&>(*this).as_length()); }
+
+    bool is_linear_gradient() const { return type() == Type::LinearGradient; }
+    LinearGradientStyleValue const& as_linear_gradient() const;
+    LinearGradientStyleValue& as_linear_gradient() { return const_cast<LinearGradientStyleValue&>(const_cast<StyleValue const&>(*this).as_linear_gradient()); }
+
+    bool is_math_depth() const { return type() == Type::MathDepth; }
+    MathDepthStyleValue const& as_math_depth() const;
+    MathDepthStyleValue& as_math_depth() { return const_cast<MathDepthStyleValue&>(const_cast<StyleValue const&>(*this).as_math_depth()); }
+
+    bool is_number() const { return type() == Type::Number; }
+    NumberStyleValue const& as_number() const;
+    NumberStyleValue& as_number() { return const_cast<NumberStyleValue&>(const_cast<StyleValue const&>(*this).as_number()); }
+
+    bool is_percentage() const { return type() == Type::Percentage; }
+    PercentageStyleValue const& as_percentage() const;
+    PercentageStyleValue& as_percentage() { return const_cast<PercentageStyleValue&>(const_cast<StyleValue const&>(*this).as_percentage()); }
+
+    bool is_position() const { return type() == Type::Position; }
+    PositionStyleValue const& as_position() const;
+
+    PositionStyleValue& as_position() { return const_cast<PositionStyleValue&>(const_cast<StyleValue const&>(*this).as_position()); }
+    bool is_radial_gradient() const { return type() == Type::RadialGradient; }
+    RadialGradientStyleValue const& as_radial_gradient() const;
+    RadialGradientStyleValue& as_radial_gradient() { return const_cast<RadialGradientStyleValue&>(const_cast<StyleValue const&>(*this).as_radial_gradient()); }
+
+    bool is_ratio() const { return type() == Type::Ratio; }
+    RatioStyleValue const& as_ratio() const;
+    RatioStyleValue& as_ratio() { return const_cast<RatioStyleValue&>(const_cast<StyleValue const&>(*this).as_ratio()); }
+
+    bool is_rect() const { return type() == Type::Rect; }
+    RectStyleValue const& as_rect() const;
+    RectStyleValue& as_rect() { return const_cast<RectStyleValue&>(const_cast<StyleValue const&>(*this).as_rect()); }
+
+    bool is_resolution() const { return type() == Type::Resolution; }
+    ResolutionStyleValue const& as_resolution() const;
+    ResolutionStyleValue& as_resolution() { return const_cast<ResolutionStyleValue&>(const_cast<StyleValue const&>(*this).as_resolution()); }
+
+    bool is_revert() const { return type() == Type::Revert; }
+    RevertStyleValue const& as_revert() const;
+    RevertStyleValue& as_revert() { return const_cast<RevertStyleValue&>(const_cast<StyleValue const&>(*this).as_revert()); }
+
+    bool is_scrollbar_gutter() const { return type() == Type::ScrollbarGutter; }
+    ScrollbarGutterStyleValue const& as_scrollbar_gutter() const;
+    ScrollbarGutterStyleValue& as_scrollbar_gutter() { return const_cast<ScrollbarGutterStyleValue&>(const_cast<StyleValue const&>(*this).as_scrollbar_gutter()); }
+
+    bool is_shadow() const { return type() == Type::Shadow; }
+    ShadowStyleValue const& as_shadow() const;
+    ShadowStyleValue& as_shadow() { return const_cast<ShadowStyleValue&>(const_cast<StyleValue const&>(*this).as_shadow()); }
+
+    bool is_shorthand() const { return type() == Type::Shorthand; }
+    ShorthandStyleValue const& as_shorthand() const;
+    ShorthandStyleValue& as_shorthand() { return const_cast<ShorthandStyleValue&>(const_cast<StyleValue const&>(*this).as_shorthand()); }
+
+    bool is_string() const { return type() == Type::String; }
+    StringStyleValue const& as_string() const;
+    StringStyleValue& as_string() { return const_cast<StringStyleValue&>(const_cast<StyleValue const&>(*this).as_string()); }
+
+    bool is_time() const { return type() == Type::Time; }
+    TimeStyleValue const& as_time() const;
+    TimeStyleValue& as_time() { return const_cast<TimeStyleValue&>(const_cast<StyleValue const&>(*this).as_time()); }
+
+    bool is_transformation() const { return type() == Type::Transformation; }
+    TransformationStyleValue const& as_transformation() const;
+    TransformationStyleValue& as_transformation() { return const_cast<TransformationStyleValue&>(const_cast<StyleValue const&>(*this).as_transformation()); }
+
+    bool is_transition() const { return type() == Type::Transition; }
+    TransitionStyleValue const& as_transition() const;
+    TransitionStyleValue& as_transition() { return const_cast<TransitionStyleValue&>(const_cast<StyleValue const&>(*this).as_transition()); }
+
+    bool is_unresolved() const { return type() == Type::Unresolved; }
+    UnresolvedStyleValue const& as_unresolved() const;
+    UnresolvedStyleValue& as_unresolved() { return const_cast<UnresolvedStyleValue&>(const_cast<StyleValue const&>(*this).as_unresolved()); }
+
+    bool is_unset() const { return type() == Type::Unset; }
+    UnsetStyleValue const& as_unset() const;
+    UnsetStyleValue& as_unset() { return const_cast<UnsetStyleValue&>(const_cast<StyleValue const&>(*this).as_unset()); }
+
+    bool is_url() const { return type() == Type::URL; }
+    URLStyleValue const& as_url() const;
+    URLStyleValue& as_url() { return const_cast<URLStyleValue&>(const_cast<StyleValue const&>(*this).as_url()); }
+
+    bool is_value_list() const { return type() == Type::ValueList; }
+    StyleValueList const& as_value_list() const;
+    StyleValueList& as_value_list() { return const_cast<StyleValueList&>(const_cast<StyleValue const&>(*this).as_value_list()); }
+
     // https://www.w3.org/TR/css-values-4/#common-keywords
     // https://drafts.csswg.org/css-cascade-4/#valdef-all-revert
     bool is_css_wide_keyword() const { return is_inherit() || is_initial() || is_revert() || is_unset(); }