From c4694c1624c5091e48e48f4c4869400f018ec99d Mon Sep 17 00:00:00 2001
From: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
Date: Tue, 3 Jun 2025 23:02:45 +0200
Subject: [PATCH 1/8] split layout into multiple modules

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
---
 plotly/src/layout/annotation.rs | 420 ++++++++++++++++++++++++++++++++
 plotly/src/layout/mod.rs        | 395 +-----------------------------
 2 files changed, 424 insertions(+), 391 deletions(-)
 create mode 100644 plotly/src/layout/annotation.rs

diff --git a/plotly/src/layout/annotation.rs b/plotly/src/layout/annotation.rs
new file mode 100644
index 00000000..6ef0bb5d
--- /dev/null
+++ b/plotly/src/layout/annotation.rs
@@ -0,0 +1,420 @@
+use plotly_derive::FieldSetter;
+use serde::{Serialize, Serializer};
+
+use crate::color::Color;
+use crate::common::{Anchor, Font, Label};
+use crate::private::NumOrString;
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum VAlign {
+    Top,
+    Middle,
+    Bottom,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum HAlign {
+    Left,
+    Center,
+    Right,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ArrowSide {
+    End,
+    Start,
+    #[serde(rename = "end+start")]
+    StartEnd,
+    None,
+}
+
+#[derive(Debug, Clone)]
+pub enum ClickToShow {
+    False,
+    OnOff,
+    OnOut,
+}
+
+impl Serialize for ClickToShow {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            Self::False => serializer.serialize_bool(false),
+            Self::OnOff => serializer.serialize_str("onoff"),
+            Self::OnOut => serializer.serialize_str("onout"),
+        }
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct Annotation {
+    /// Determines whether or not this annotation is visible.
+    visible: Option<bool>,
+    /// Sets the text associated with this annotation. Plotly uses a subset of
+    /// HTML tags to do things like newline (<br>), bold (<b></b>), italics
+    /// (<i></i>), hyperlinks (<a href='...'></a>). Tags <em></em>, <sup></sup>,
+    /// <sub></sub> <span></span> are also supported.
+    text: Option<String>,
+    /// Sets the angle at which the `text` is drawn with respect to the
+    /// horizontal.
+    #[serde(rename = "textangle")]
+    text_angle: Option<f64>,
+    /// Sets the annotation text font.
+    font: Option<Font>,
+    /// Sets an explicit width for the text box. null (default) lets the text
+    /// set the box width. Wider text will be clipped. There is no automatic
+    /// wrapping; use <br> to start a new line.
+    width: Option<f64>,
+    /// Sets an explicit height for the text box. null (default) lets the text
+    /// set the box height. Taller text will be clipped.
+    height: Option<f64>,
+    /// Sets the opacity of the annotation (text + arrow).
+    opacity: Option<f64>,
+    /// Sets the horizontal alignment of the `text` within the box. Has an
+    /// effect only if `text` spans two or more lines (i.e. `text` contains
+    /// one or more <br> HTML tags) or if an explicit width is set to
+    /// override the text width.
+    align: Option<HAlign>,
+    /// Sets the vertical alignment of the `text` within the box. Has an effect
+    /// only if an explicit height is set to override the text height.
+    valign: Option<VAlign>,
+    /// Sets the background color of the annotation.
+    #[serde(rename = "bgcolor")]
+    background_color: Option<Box<dyn Color>>,
+    /// Sets the color of the border enclosing the annotation `text`.
+    #[serde(rename = "bordercolor")]
+    border_color: Option<Box<dyn Color>>,
+    /// Sets the padding (in px) between the `text` and the enclosing border.
+    #[serde(rename = "borderpad")]
+    border_pad: Option<f64>,
+    /// Sets the width (in px) of the border enclosing the annotation `text`.
+    #[serde(rename = "borderwidth")]
+    border_width: Option<f64>,
+    /// Determines whether or not the annotation is drawn with an arrow. If
+    /// "True", `text` is placed near the arrow's tail. If "False", `text`
+    /// lines up with the `x` and `y` provided.
+    #[serde(rename = "showarrow")]
+    show_arrow: Option<bool>,
+    /// Sets the color of the annotation arrow.
+    #[serde(rename = "arrowcolor")]
+    arrow_color: Option<Box<dyn Color>>,
+    /// Sets the end annotation arrow head style. Integer between or equal to 0
+    /// and 8.
+    #[serde(rename = "arrowhead")]
+    arrow_head: Option<u8>,
+    /// Sets the start annotation arrow head style. Integer between or equal to
+    /// 0 and 8.
+    #[serde(rename = "startarrowhead")]
+    start_arrow_head: Option<u8>,
+    /// Sets the annotation arrow head position.
+    #[serde(rename = "arrowside")]
+    arrow_side: Option<ArrowSide>,
+    /// Sets the size of the end annotation arrow head, relative to
+    /// `arrowwidth`. A value of 1 (default) gives a head about 3x as wide
+    /// as the line.
+    #[serde(rename = "arrowsize")]
+    arrow_size: Option<f64>,
+    /// Sets the size of the start annotation arrow head, relative to
+    /// `arrowwidth`. A value of 1 (default) gives a head about 3x as wide
+    /// as the line.
+    #[serde(rename = "startarrowsize")]
+    start_arrow_size: Option<f64>,
+    /// Sets the width (in px) of annotation arrow line.
+    #[serde(rename = "arrowwidth")]
+    arrow_width: Option<f64>,
+    /// Sets a distance, in pixels, to move the end arrowhead away from the
+    /// position it is pointing at, for example to point at the edge of a
+    /// marker independent of zoom. Note that this shortens the arrow from
+    /// the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which
+    /// moves everything by this amount.
+    #[serde(rename = "standoff")]
+    stand_off: Option<f64>,
+    /// Sets a distance, in pixels, to move the start arrowhead away from the
+    /// position it is pointing at, for example to point at the edge of a
+    /// marker independent of zoom. Note that this shortens the arrow from
+    /// the `ax` / `ay` vector, in contrast to `xshift` / `yshift`
+    /// which moves everything by this amount.
+    #[serde(rename = "startstandoff")]
+    start_stand_off: Option<f64>,
+    /// Sets the x component of the arrow tail about the arrow head. If `axref`
+    /// is `pixel`, a positive (negative) component corresponds to an arrow
+    /// pointing from right to left (left to right). If `axref` is an axis,
+    /// this is an absolute value on that axis, like `x`, NOT a
+    /// relative value.
+    ax: Option<NumOrString>,
+    /// Sets the y component of the arrow tail about the arrow head. If `ayref`
+    /// is `pixel`, a positive (negative) component corresponds to an arrow
+    /// pointing from bottom to top (top to bottom). If `ayref` is an axis,
+    /// this is an absolute value on that axis, like `y`, NOT a
+    /// relative value.
+    ay: Option<NumOrString>,
+    /// Indicates in what terms the tail of the annotation (ax,ay) is specified.
+    /// If `pixel`, `ax` is a relative offset in pixels from `x`. If set to
+    /// an x axis id (e.g. "x" or "x2"), `ax` is specified in the same terms
+    /// as that axis. This is useful for trendline annotations which
+    /// should continue to indicate the correct trend when zoomed.
+    #[serde(rename = "axref")]
+    ax_ref: Option<String>,
+    /// Indicates in what terms the tail of the annotation (ax,ay) is specified.
+    /// If `pixel`, `ay` is a relative offset in pixels from `y`. If set to
+    /// a y axis id (e.g. "y" or "y2"), `ay` is specified in the same terms
+    /// as that axis. This is useful for trendline annotations which
+    /// should continue to indicate the correct trend when zoomed.
+    #[serde(rename = "ayref")]
+    ay_ref: Option<String>,
+    /// Sets the annotation's x coordinate axis. If set to an x axis id (e.g.
+    /// "x" or "x2"), the `x` position refers to an x coordinate If set to
+    /// "paper", the `x` position refers to the distance from the left side
+    /// of the plotting area in normalized coordinates where 0 (1)
+    /// corresponds to the left (right) side.
+    #[serde(rename = "xref")]
+    x_ref: Option<String>,
+    /// Sets the annotation's x position. If the axis `type` is "log", then you
+    /// must take the log of your desired range. If the axis `type` is
+    /// "date", it should be date strings, like date data, though Date
+    /// objects and unix milliseconds will be accepted and converted to strings.
+    /// If the axis `type` is "category", it should be numbers, using the scale
+    /// where each category is assigned a serial number from zero in the
+    /// order it appears.
+    x: Option<NumOrString>,
+    /// Sets the text box's horizontal position anchor This anchor binds the `x`
+    /// position to the "left", "center" or "right" of the annotation. For
+    /// example, if `x` is set to 1, `xref` to "paper" and `xanchor` to
+    /// "right" then the right-most portion of the annotation lines up with
+    /// the right-most edge of the plotting area. If "auto", the anchor is
+    /// equivalent to "center" for data-referenced annotations or if there
+    /// is an arrow, whereas for paper-referenced with no arrow, the anchor
+    /// picked corresponds to the closest side.
+    #[serde(rename = "xanchor")]
+    x_anchor: Option<Anchor>,
+    /// Shifts the position of the whole annotation and arrow to the right
+    /// (positive) or left (negative) by this many pixels.
+    #[serde(rename = "xshift")]
+    x_shift: Option<f64>,
+    /// Sets the annotation's y coordinate axis. If set to an y axis id (e.g.
+    /// "y" or "y2"), the `y` position refers to an y coordinate If set to
+    /// "paper", the `y` position refers to the distance from the bottom of
+    /// the plotting area in normalized coordinates where 0 (1) corresponds
+    /// to the bottom (top).
+    #[serde(rename = "yref")]
+    y_ref: Option<String>,
+    /// Sets the annotation's y position. If the axis `type` is "log", then you
+    /// must take the log of your desired range. If the axis `type` is
+    /// "date", it should be date strings, like date data, though Date
+    /// objects and unix milliseconds will be accepted and converted to strings.
+    /// If the axis `type` is "category", it should be numbers, using the
+    /// scale where each category is assigned a serial number from zero in
+    /// the order it appears.
+    y: Option<NumOrString>,
+    /// Sets the text box's vertical position anchor This anchor binds the `y`
+    /// position to the "top", "middle" or "bottom" of the annotation. For
+    /// example, if `y` is set to 1, `yref` to "paper" and `yanchor` to
+    /// "top" then the top-most portion of the annotation lines up with the
+    /// top-most edge of the plotting area. If "auto", the anchor is equivalent
+    /// to "middle" for data-referenced annotations or if there is an arrow,
+    /// whereas for paper-referenced with no arrow, the anchor picked
+    /// corresponds to the closest side.
+    #[serde(rename = "yanchor")]
+    y_anchor: Option<Anchor>,
+    /// Shifts the position of the whole annotation and arrow up (positive) or
+    /// down (negative) by this many pixels.
+    #[serde(rename = "yshift")]
+    y_shift: Option<f64>,
+    /// Makes this annotation respond to clicks on the plot. If you click a data
+    /// point that exactly matches the `x` and `y` values of this
+    /// annotation, and it is hidden (visible: false), it will appear. In
+    /// "onoff" mode, you must click the same point again to make it disappear,
+    /// so if you click multiple points, you can show multiple annotations.
+    /// In "onout" mode, a click anywhere else in the plot (on another data
+    /// point or not) will hide this annotation. If you need to show/hide
+    /// this annotation in response to different `x` or `y` values, you can set
+    /// `xclick` and/or `yclick`. This is useful for example to label the side
+    /// of a bar. To label markers though, `standoff` is preferred over
+    /// `xclick` and `yclick`.
+    #[serde(rename = "clicktoshow")]
+    click_to_show: Option<ClickToShow>,
+    /// Toggle this annotation when clicking a data point whose `x` value is
+    /// `xclick` rather than the annotation's `x` value.
+    #[serde(rename = "xclick")]
+    x_click: Option<NumOrString>,
+    /// Toggle this annotation when clicking a data point whose `y` value is
+    /// `yclick` rather than the annotation's `y` value.
+    #[serde(rename = "yclick")]
+    y_click: Option<NumOrString>,
+    /// Sets text to appear when hovering over this annotation. If omitted or
+    /// blank, no hover label will appear.
+    #[serde(rename = "hovertext")]
+    hover_text: Option<String>,
+    /// Label displayed on mouse hover.
+    #[serde(rename = "hoverlabel")]
+    hover_label: Option<Label>,
+    /// Determines whether the annotation text box captures mouse move and click
+    /// events, or allows those events to pass through to data points in the
+    /// plot that may be behind the annotation. By default `captureevents`
+    /// is "false" unless `hovertext` is provided. If you use the event
+    /// `plotly_clickannotation` without `hovertext` you must explicitly enable
+    /// `captureevents`.
+    #[serde(rename = "captureevents")]
+    capture_events: Option<bool>,
+    /// When used in a template, named items are created in the output figure in
+    /// addition to any items the figure already has in this array. You can
+    /// modify these items in the output figure by making your own item with
+    /// `templateitemname` matching this `name` alongside your modifications
+    /// (including `visible: false` or `enabled: false` to hide it). Has no
+    /// effect outside of a template.
+    name: Option<String>,
+    /// Used to refer to a named item in this array in the template. Named items
+    /// from the template will be created even without a matching item in
+    /// the input figure, but you can modify one by making an item with
+    /// `templateitemname` matching its `name`, alongside your modifications
+    /// (including `visible: false` or `enabled: false` to hide it). If there is
+    /// no template or no matching item, this item will be hidden unless you
+    /// explicitly show it with `visible: true`.
+    #[serde(rename = "templateitemname")]
+    template_item_name: Option<String>,
+}
+
+impl Annotation {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::{json, to_value};
+
+    use crate::common::{Anchor, Font, Label};
+
+    #[test]
+    fn serialize_valign() {
+        assert_eq!(to_value(VAlign::Top).unwrap(), json!("top"));
+        assert_eq!(to_value(VAlign::Middle).unwrap(), json!("middle"));
+        assert_eq!(to_value(VAlign::Bottom).unwrap(), json!("bottom"));
+    }
+
+    #[test]
+    fn serialize_halign() {
+        assert_eq!(to_value(HAlign::Left).unwrap(), json!("left"));
+        assert_eq!(to_value(HAlign::Center).unwrap(), json!("center"));
+        assert_eq!(to_value(HAlign::Right).unwrap(), json!("right"));
+    }
+
+    #[test]
+    fn serialize_click_to_show() {
+        assert_eq!(to_value(ClickToShow::False).unwrap(), json!(false));
+        assert_eq!(to_value(ClickToShow::OnOff).unwrap(), json!("onoff"));
+        assert_eq!(to_value(ClickToShow::OnOut).unwrap(), json!("onout"));
+    }
+
+    #[test]
+    fn serialize_arrow_side() {
+        assert_eq!(to_value(ArrowSide::End).unwrap(), json!("end"));
+        assert_eq!(to_value(ArrowSide::Start).unwrap(), json!("start"));
+        assert_eq!(to_value(ArrowSide::StartEnd).unwrap(), json!("end+start"));
+        assert_eq!(to_value(ArrowSide::None).unwrap(), json!("none"));
+    }
+
+    #[test]
+    fn serialize_annotation() {
+        let annotation = Annotation::new()
+            .align(HAlign::Center)
+            .arrow_color("#464646")
+            .arrow_head(2)
+            .arrow_size(123.4)
+            .arrow_side(ArrowSide::End)
+            .arrow_width(111.1)
+            .ax("ax")
+            .ax_ref("axref")
+            .ay("ay")
+            .ay_ref("ayref")
+            .background_color("#123456")
+            .border_color("#456789")
+            .border_pad(500.)
+            .border_width(1000.)
+            .capture_events(false)
+            .click_to_show(ClickToShow::OnOff)
+            .font(Font::new())
+            .height(6.)
+            .hover_label(Label::new())
+            .hover_text("hovertext")
+            .name("name")
+            .opacity(0.01)
+            .show_arrow(false)
+            .stand_off(999.9)
+            .start_arrow_head(0)
+            .start_stand_off(8.8)
+            .start_arrow_size(456.7)
+            .template_item_name("templateitemname")
+            .text("text")
+            .text_angle(5.)
+            .valign(VAlign::Middle)
+            .visible(true)
+            .width(4.)
+            .x_ref("xref")
+            .x("x")
+            .x_anchor(Anchor::Auto)
+            .x_click("xclick")
+            .x_shift(4.0)
+            .y_ref("yref")
+            .y("y")
+            .y_anchor(Anchor::Bottom)
+            .y_click("yclick")
+            .y_shift(6.3);
+
+        let expected = json!({
+            "visible": true,
+            "text": "text",
+            "textangle": 5.0,
+            "font": {},
+            "width": 4.0,
+            "height": 6.0,
+            "opacity": 0.01,
+            "align": "center",
+            "valign": "middle",
+            "bgcolor": "#123456",
+            "bordercolor": "#456789",
+            "borderpad": 500.0,
+            "borderwidth": 1000.0,
+            "showarrow": false,
+            "arrowcolor": "#464646",
+            "arrowhead": 2,
+            "startarrowhead": 0,
+            "arrowside": "end",
+            "arrowsize": 123.4,
+            "startarrowsize": 456.7,
+            "arrowwidth": 111.1,
+            "standoff": 999.9,
+            "startstandoff": 8.8,
+            "ax": "ax",
+            "ay": "ay",
+            "x": "x",
+            "y": "y",
+            "axref": "axref",
+            "ayref": "ayref",
+            "xref": "xref",
+            "yref": "yref",
+            "xanchor": "auto",
+            "yanchor": "bottom",
+            "xshift": 4.0,
+            "yshift": 6.3,
+            "clicktoshow": "onoff",
+            "xclick": "xclick",
+            "yclick": "yclick",
+            "hovertext": "hovertext",
+            "hoverlabel": {},
+            "captureevents": false,
+            "name": "name",
+            "templateitemname": "templateitemname",
+        });
+
+        assert_eq!(to_value(annotation).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index b3af4e60..33cf54b2 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -1,6 +1,10 @@
 pub mod themes;
 pub mod update_menu;
 
+// Re-export moved types
+mod annotation;
+pub use self::annotation::{Annotation, ArrowSide, ClickToShow, HAlign, VAlign};
+
 use std::borrow::Cow;
 
 use plotly_derive::FieldSetter;
@@ -202,22 +206,6 @@ impl Legend {
     }
 }
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum VAlign {
-    Top,
-    Middle,
-    Bottom,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum HAlign {
-    Left,
-    Center,
-    Right,
-}
-
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
 pub struct Margin {
@@ -1036,271 +1024,6 @@ impl ActiveShape {
     }
 }
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ArrowSide {
-    End,
-    Start,
-    #[serde(rename = "end+start")]
-    StartEnd,
-    None,
-}
-
-#[derive(Debug, Clone)]
-pub enum ClickToShow {
-    False,
-    OnOff,
-    OnOut,
-}
-
-impl Serialize for ClickToShow {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Self::False => serializer.serialize_bool(false),
-            Self::OnOff => serializer.serialize_str("onoff"),
-            Self::OnOut => serializer.serialize_str("onout"),
-        }
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct Annotation {
-    /// Determines whether or not this annotation is visible.
-    visible: Option<bool>,
-    /// Sets the text associated with this annotation. Plotly uses a subset of
-    /// HTML tags to do things like newline (<br>), bold (<b></b>), italics
-    /// (<i></i>), hyperlinks (<a href='...'></a>). Tags <em></em>, <sup></sup>,
-    /// <sub></sub> <span></span> are also supported.
-    text: Option<String>,
-    /// Sets the angle at which the `text` is drawn with respect to the
-    /// horizontal.
-    #[serde(rename = "textangle")]
-    text_angle: Option<f64>,
-    /// Sets the annotation text font.
-    font: Option<Font>,
-    /// Sets an explicit width for the text box. null (default) lets the text
-    /// set the box width. Wider text will be clipped. There is no automatic
-    /// wrapping; use <br> to start a new line.
-    width: Option<f64>,
-    /// Sets an explicit height for the text box. null (default) lets the text
-    /// set the box height. Taller text will be clipped.
-    height: Option<f64>,
-    /// Sets the opacity of the annotation (text + arrow).
-    opacity: Option<f64>,
-    /// Sets the horizontal alignment of the `text` within the box. Has an
-    /// effect only if `text` spans two or more lines (i.e. `text` contains
-    /// one or more <br> HTML tags) or if an explicit width is set to
-    /// override the text width.
-    align: Option<HAlign>,
-    /// Sets the vertical alignment of the `text` within the box. Has an effect
-    /// only if an explicit height is set to override the text height.
-    valign: Option<VAlign>,
-    /// Sets the background color of the annotation.
-    #[serde(rename = "bgcolor")]
-    background_color: Option<Box<dyn Color>>,
-    /// Sets the color of the border enclosing the annotation `text`.
-    #[serde(rename = "bordercolor")]
-    border_color: Option<Box<dyn Color>>,
-    /// Sets the padding (in px) between the `text` and the enclosing border.
-    #[serde(rename = "borderpad")]
-    border_pad: Option<f64>,
-    /// Sets the width (in px) of the border enclosing the annotation `text`.
-    #[serde(rename = "borderwidth")]
-    border_width: Option<f64>,
-    /// Determines whether or not the annotation is drawn with an arrow. If
-    /// "True", `text` is placed near the arrow's tail. If "False", `text`
-    /// lines up with the `x` and `y` provided.
-    #[serde(rename = "showarrow")]
-    show_arrow: Option<bool>,
-    /// Sets the color of the annotation arrow.
-    #[serde(rename = "arrowcolor")]
-    arrow_color: Option<Box<dyn Color>>,
-    /// Sets the end annotation arrow head style. Integer between or equal to 0
-    /// and 8.
-    #[serde(rename = "arrowhead")]
-    arrow_head: Option<u8>,
-    /// Sets the start annotation arrow head style. Integer between or equal to
-    /// 0 and 8.
-    #[serde(rename = "startarrowhead")]
-    start_arrow_head: Option<u8>,
-    /// Sets the annotation arrow head position.
-    #[serde(rename = "arrowside")]
-    arrow_side: Option<ArrowSide>,
-    /// Sets the size of the end annotation arrow head, relative to
-    /// `arrowwidth`. A value of 1 (default) gives a head about 3x as wide
-    /// as the line.
-    #[serde(rename = "arrowsize")]
-    arrow_size: Option<f64>,
-    /// Sets the size of the start annotation arrow head, relative to
-    /// `arrowwidth`. A value of 1 (default) gives a head about 3x as wide
-    /// as the line.
-    #[serde(rename = "startarrowsize")]
-    start_arrow_size: Option<f64>,
-    /// Sets the width (in px) of annotation arrow line.
-    #[serde(rename = "arrowwidth")]
-    arrow_width: Option<f64>,
-    /// Sets a distance, in pixels, to move the end arrowhead away from the
-    /// position it is pointing at, for example to point at the edge of a
-    /// marker independent of zoom. Note that this shortens the arrow from
-    /// the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which
-    /// moves everything by this amount.
-    #[serde(rename = "standoff")]
-    stand_off: Option<f64>,
-    /// Sets a distance, in pixels, to move the start arrowhead away from the
-    /// position it is pointing at, for example to point at the edge of a
-    /// marker independent of zoom. Note that this shortens the arrow from
-    /// the `ax` / `ay` vector, in contrast to `xshift` / `yshift`
-    /// which moves everything by this amount.
-    #[serde(rename = "startstandoff")]
-    start_stand_off: Option<f64>,
-    /// Sets the x component of the arrow tail about the arrow head. If `axref`
-    /// is `pixel`, a positive (negative) component corresponds to an arrow
-    /// pointing from right to left (left to right). If `axref` is an axis,
-    /// this is an absolute value on that axis, like `x`, NOT a
-    /// relative value.
-    ax: Option<NumOrString>,
-    /// Sets the y component of the arrow tail about the arrow head. If `ayref`
-    /// is `pixel`, a positive (negative) component corresponds to an arrow
-    /// pointing from bottom to top (top to bottom). If `ayref` is an axis,
-    /// this is an absolute value on that axis, like `y`, NOT a
-    /// relative value.
-    ay: Option<NumOrString>,
-    /// Indicates in what terms the tail of the annotation (ax,ay) is specified.
-    /// If `pixel`, `ax` is a relative offset in pixels from `x`. If set to
-    /// an x axis id (e.g. "x" or "x2"), `ax` is specified in the same terms
-    /// as that axis. This is useful for trendline annotations which
-    /// should continue to indicate the correct trend when zoomed.
-    #[serde(rename = "axref")]
-    ax_ref: Option<String>,
-    /// Indicates in what terms the tail of the annotation (ax,ay) is specified.
-    /// If `pixel`, `ay` is a relative offset in pixels from `y`. If set to
-    /// a y axis id (e.g. "y" or "y2"), `ay` is specified in the same terms
-    /// as that axis. This is useful for trendline annotations which
-    /// should continue to indicate the correct trend when zoomed.
-    #[serde(rename = "ayref")]
-    ay_ref: Option<String>,
-    /// Sets the annotation's x coordinate axis. If set to an x axis id (e.g.
-    /// "x" or "x2"), the `x` position refers to an x coordinate If set to
-    /// "paper", the `x` position refers to the distance from the left side
-    /// of the plotting area in normalized coordinates where 0 (1)
-    /// corresponds to the left (right) side.
-    #[serde(rename = "xref")]
-    x_ref: Option<String>,
-    /// Sets the annotation's x position. If the axis `type` is "log", then you
-    /// must take the log of your desired range. If the axis `type` is
-    /// "date", it should be date strings, like date data, though Date
-    /// objects and unix milliseconds will be accepted and converted to strings.
-    /// If the axis `type` is "category", it should be numbers, using the scale
-    /// where each category is assigned a serial number from zero in the
-    /// order it appears.
-    x: Option<NumOrString>,
-    /// Sets the text box's horizontal position anchor This anchor binds the `x`
-    /// position to the "left", "center" or "right" of the annotation. For
-    /// example, if `x` is set to 1, `xref` to "paper" and `xanchor` to
-    /// "right" then the right-most portion of the annotation lines up with
-    /// the right-most edge of the plotting area. If "auto", the anchor is
-    /// equivalent to "center" for data-referenced annotations or if there
-    /// is an arrow, whereas for paper-referenced with no arrow, the anchor
-    /// picked corresponds to the closest side.
-    #[serde(rename = "xanchor")]
-    x_anchor: Option<Anchor>,
-    /// Shifts the position of the whole annotation and arrow to the right
-    /// (positive) or left (negative) by this many pixels.
-    #[serde(rename = "xshift")]
-    x_shift: Option<f64>,
-    /// Sets the annotation's y coordinate axis. If set to an y axis id (e.g.
-    /// "y" or "y2"), the `y` position refers to an y coordinate If set to
-    /// "paper", the `y` position refers to the distance from the bottom of
-    /// the plotting area in normalized coordinates where 0 (1) corresponds
-    /// to the bottom (top).
-    #[serde(rename = "yref")]
-    y_ref: Option<String>,
-    /// Sets the annotation's y position. If the axis `type` is "log", then you
-    /// must take the log of your desired range. If the axis `type` is
-    /// "date", it should be date strings, like date data, though Date
-    /// objects and unix milliseconds will be accepted and converted to strings.
-    /// If the axis `type` is "category", it should be numbers, using the
-    /// scale where each category is assigned a serial number from zero in
-    /// the order it appears.
-    y: Option<NumOrString>,
-    /// Sets the text box's vertical position anchor This anchor binds the `y`
-    /// position to the "top", "middle" or "bottom" of the annotation. For
-    /// example, if `y` is set to 1, `yref` to "paper" and `yanchor` to
-    /// "top" then the top-most portion of the annotation lines up with the
-    /// top-most edge of the plotting area. If "auto", the anchor is equivalent
-    /// to "middle" for data-referenced annotations or if there is an arrow,
-    /// whereas for paper-referenced with no arrow, the anchor picked
-    /// corresponds to the closest side.
-    #[serde(rename = "yanchor")]
-    y_anchor: Option<Anchor>,
-    /// Shifts the position of the whole annotation and arrow up (positive) or
-    /// down (negative) by this many pixels.
-    #[serde(rename = "yshift")]
-    y_shift: Option<f64>,
-    /// Makes this annotation respond to clicks on the plot. If you click a data
-    /// point that exactly matches the `x` and `y` values of this
-    /// annotation, and it is hidden (visible: false), it will appear. In
-    /// "onoff" mode, you must click the same point again to make it disappear,
-    /// so if you click multiple points, you can show multiple annotations.
-    /// In "onout" mode, a click anywhere else in the plot (on another data
-    /// point or not) will hide this annotation. If you need to show/hide
-    /// this annotation in response to different `x` or `y` values, you can set
-    /// `xclick` and/or `yclick`. This is useful for example to label the side
-    /// of a bar. To label markers though, `standoff` is preferred over
-    /// `xclick` and `yclick`.
-    #[serde(rename = "clicktoshow")]
-    click_to_show: Option<ClickToShow>,
-    /// Toggle this annotation when clicking a data point whose `x` value is
-    /// `xclick` rather than the annotation's `x` value.
-    #[serde(rename = "xclick")]
-    x_click: Option<NumOrString>,
-    /// Toggle this annotation when clicking a data point whose `y` value is
-    /// `yclick` rather than the annotation's `y` value.
-    #[serde(rename = "yclick")]
-    y_click: Option<NumOrString>,
-    /// Sets text to appear when hovering over this annotation. If omitted or
-    /// blank, no hover label will appear.
-    #[serde(rename = "hovertext")]
-    hover_text: Option<String>,
-    /// Label displayed on mouse hover.
-    #[serde(rename = "hoverlabel")]
-    hover_label: Option<Label>,
-    /// Determines whether the annotation text box captures mouse move and click
-    /// events, or allows those events to pass through to data points in the
-    /// plot that may be behind the annotation. By default `captureevents`
-    /// is "false" unless `hovertext` is provided. If you use the event
-    /// `plotly_clickannotation` without `hovertext` you must explicitly enable
-    /// `captureevents`.
-    #[serde(rename = "captureevents")]
-    capture_events: Option<bool>,
-    /// When used in a template, named items are created in the output figure in
-    /// addition to any items the figure already has in this array. You can
-    /// modify these items in the output figure by making your own item with
-    /// `templateitemname` matching this `name` alongside your modifications
-    /// (including `visible: false` or `enabled: false` to hide it). Has no
-    /// effect outside of a template.
-    name: Option<String>,
-    /// Used to refer to a named item in this array in the template. Named items
-    /// from the template will be created even without a matching item in
-    /// the input figure, but you can modify one by making an item with
-    /// `templateitemname` matching its `name`, alongside your modifications
-    /// (including `visible: false` or `enabled: false` to hide it). If there is
-    /// no template or no matching item, this item will be hidden unless you
-    /// explicitly show it with `visible: true`.
-    #[serde(rename = "templateitemname")]
-    template_item_name: Option<String>,
-}
-
-impl Annotation {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
 #[derive(Serialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum ClickMode {
@@ -2272,20 +1995,6 @@ mod tests {
         assert_eq!(to_value(legend).unwrap(), expected)
     }
 
-    #[test]
-    fn serialize_valign() {
-        assert_eq!(to_value(VAlign::Top).unwrap(), json!("top"));
-        assert_eq!(to_value(VAlign::Middle).unwrap(), json!("middle"));
-        assert_eq!(to_value(VAlign::Bottom).unwrap(), json!("bottom"));
-    }
-
-    #[test]
-    fn serialize_halign() {
-        assert_eq!(to_value(HAlign::Left).unwrap(), json!("left"));
-        assert_eq!(to_value(HAlign::Center).unwrap(), json!("center"));
-        assert_eq!(to_value(HAlign::Right).unwrap(), json!("right"));
-    }
-
     #[test]
     fn serialize_margin() {
         let margin = Margin::new()
@@ -2901,102 +2610,6 @@ mod tests {
         assert_eq!(to_value(ArrowSide::None).unwrap(), json!("none"));
     }
 
-    #[test]
-    fn serialize_annotation() {
-        let annotation = Annotation::new()
-            .align(HAlign::Center)
-            .arrow_color("#464646")
-            .arrow_head(2)
-            .arrow_size(123.4)
-            .arrow_side(ArrowSide::End)
-            .arrow_width(111.1)
-            .ax("ax")
-            .ax_ref("axref")
-            .ay("ay")
-            .ay_ref("ayref")
-            .background_color("#123456")
-            .border_color("#456789")
-            .border_pad(500.)
-            .border_width(1000.)
-            .capture_events(false)
-            .click_to_show(ClickToShow::OnOff)
-            .font(Font::new())
-            .height(6.)
-            .hover_label(Label::new())
-            .hover_text("hovertext")
-            .name("name")
-            .opacity(0.01)
-            .show_arrow(false)
-            .stand_off(999.9)
-            .start_arrow_head(0)
-            .start_stand_off(8.8)
-            .start_arrow_size(456.7)
-            .template_item_name("templateitemname")
-            .text("text")
-            .text_angle(5.)
-            .valign(VAlign::Middle)
-            .visible(true)
-            .width(4.)
-            .x_ref("xref")
-            .x("x")
-            .x_anchor(Anchor::Auto)
-            .x_click("xclick")
-            .x_shift(4.0)
-            .y_ref("yref")
-            .y("y")
-            .y_anchor(Anchor::Bottom)
-            .y_click("yclick")
-            .y_shift(6.3);
-
-        let expected = json!({
-            "visible": true,
-            "text": "text",
-            "textangle": 5.0,
-            "font": {},
-            "width": 4.0,
-            "height": 6.0,
-            "opacity": 0.01,
-            "align": "center",
-            "valign": "middle",
-            "bgcolor": "#123456",
-            "bordercolor": "#456789",
-            "borderpad": 500.0,
-            "borderwidth": 1000.0,
-            "showarrow": false,
-            "arrowcolor": "#464646",
-            "arrowhead": 2,
-            "startarrowhead": 0,
-            "arrowside": "end",
-            "arrowsize": 123.4,
-            "startarrowsize": 456.7,
-            "arrowwidth": 111.1,
-            "standoff": 999.9,
-            "startstandoff": 8.8,
-            "ax": "ax",
-            "ay": "ay",
-            "x": "x",
-            "y": "y",
-            "axref": "axref",
-            "ayref": "ayref",
-            "xref": "xref",
-            "yref": "yref",
-            "xanchor": "auto",
-            "yanchor": "bottom",
-            "xshift": 4.0,
-            "yshift": 6.3,
-            "clicktoshow": "onoff",
-            "xclick": "xclick",
-            "yclick": "yclick",
-            "hovertext": "hovertext",
-            "hoverlabel": {},
-            "captureevents": false,
-            "name": "name",
-            "templateitemname": "templateitemname",
-        });
-
-        assert_eq!(to_value(annotation).unwrap(), expected);
-    }
-
     #[test]
     #[rustfmt::skip]
     fn serialize_click_mode() {

From c2d62b21994f66853e4da01028c68c2d520a3565 Mon Sep 17 00:00:00 2001
From: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
Date: Tue, 3 Jun 2025 23:39:56 +0200
Subject: [PATCH 2/8] extacted axis to separate module

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
---
 plotly/src/layout/annotation.rs |   2 +-
 plotly/src/layout/axis.rs       | 754 ++++++++++++++++++++++++++++++++
 plotly/src/layout/mod.rs        | 747 +------------------------------
 3 files changed, 764 insertions(+), 739 deletions(-)
 create mode 100644 plotly/src/layout/axis.rs

diff --git a/plotly/src/layout/annotation.rs b/plotly/src/layout/annotation.rs
index 6ef0bb5d..cdfbcf5d 100644
--- a/plotly/src/layout/annotation.rs
+++ b/plotly/src/layout/annotation.rs
@@ -288,9 +288,9 @@ impl Annotation {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::{json, to_value};
 
+    use super::*;
     use crate::common::{Anchor, Font, Label};
 
     #[test]
diff --git a/plotly/src/layout/axis.rs b/plotly/src/layout/axis.rs
new file mode 100644
index 00000000..c1d7f24b
--- /dev/null
+++ b/plotly/src/layout/axis.rs
@@ -0,0 +1,754 @@
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::color::Color;
+use crate::common::{
+    Anchor, AxisSide, Calendar, DashType, ExponentFormat, Font, TickFormatStop, TickMode, Title,
+};
+use crate::private::NumOrStringCollection;
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum SpikeSnap {
+    Data,
+    Cursor,
+    #[serde(rename = "hovered data")]
+    HoveredData,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum SpikeMode {
+    ToAxis,
+    Across,
+    Marker,
+    #[serde(rename = "toaxis+across")]
+    ToaxisAcross,
+    #[serde(rename = "toaxis+marker")]
+    ToAxisMarker,
+    #[serde(rename = "across+marker")]
+    AcrossMarker,
+    #[serde(rename = "toaxis+across+marker")]
+    ToaxisAcrossMarker,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum TicksDirection {
+    Outside,
+    Inside,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum TicksPosition {
+    Labels,
+    Boundaries,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum AxisType {
+    #[serde(rename = "-")]
+    Default,
+    Linear,
+    Log,
+    Date,
+    Category,
+    MultiCategory,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum AxisConstrain {
+    Range,
+    Domain,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum RangeMode {
+    Normal,
+    ToZero,
+    NonNegative,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ConstrainDirection {
+    Left,
+    Center,
+    Right,
+    Top,
+    Middle,
+    Bottom,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ArrayShow {
+    All,
+    First,
+    Last,
+    None,
+}
+
+#[derive(Serialize, Debug, Clone)]
+pub enum CategoryOrder {
+    #[serde(rename = "trace")]
+    Trace,
+    #[serde(rename = "category ascending")]
+    CategoryAscending,
+    #[serde(rename = "category descending")]
+    CategoryDescending,
+    #[serde(rename = "array")]
+    Array,
+    #[serde(rename = "total ascending")]
+    TotalAscending,
+    #[serde(rename = "total descending")]
+    TotalDescending,
+    #[serde(rename = "min ascending")]
+    MinAscending,
+    #[serde(rename = "min descending")]
+    MinDescending,
+    #[serde(rename = "max ascending")]
+    MaxAscending,
+    #[serde(rename = "max descending")]
+    MaxDescending,
+    #[serde(rename = "sum ascending")]
+    SumAscending,
+    #[serde(rename = "sum descending")]
+    SumDescending,
+    #[serde(rename = "mean ascending")]
+    MeanAscending,
+    #[serde(rename = "mean descending")]
+    MeanDescending,
+    #[serde(rename = "geometric mean ascending")]
+    GeometricMeanAscending,
+    #[serde(rename = "geometric mean descending")]
+    GeometricMeanDescending,
+    #[serde(rename = "median ascending")]
+    MedianAscending,
+    #[serde(rename = "median descending")]
+    MedianDescending,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct RangeSlider {
+    #[serde(rename = "bgcolor")]
+    background_color: Option<Box<dyn Color>>,
+    #[serde(rename = "bordercolor")]
+    border_color: Option<Box<dyn Color>>,
+    #[serde(rename = "borderwidth")]
+    border_width: Option<u64>,
+    #[serde(rename = "autorange")]
+    auto_range: Option<bool>,
+    range: Option<NumOrStringCollection>,
+    thickness: Option<f64>,
+    visible: Option<bool>,
+    #[serde(rename = "yaxis")]
+    y_axis: Option<RangeSliderYAxis>,
+}
+
+impl RangeSlider {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct RangeSliderYAxis {
+    #[serde(rename = "rangemode")]
+    range_mode: Option<SliderRangeMode>,
+    range: Option<NumOrStringCollection>,
+}
+
+impl RangeSliderYAxis {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum SliderRangeMode {
+    Auto,
+    Fixed,
+    Match,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct RangeSelector {
+    visible: Option<bool>,
+    buttons: Option<Vec<SelectorButton>>,
+    x: Option<f64>,
+    #[serde(rename = "xanchor")]
+    x_anchor: Option<Anchor>,
+    y: Option<f64>,
+    #[serde(rename = "yanchor")]
+    y_anchor: Option<Anchor>,
+    font: Option<Font>,
+    #[serde(rename = "bgcolor")]
+    background_color: Option<Box<dyn Color>>,
+    #[serde(rename = "activecolor")]
+    active_color: Option<Box<dyn Color>>,
+    #[serde(rename = "bordercolor")]
+    border_color: Option<Box<dyn Color>>,
+    #[serde(rename = "borderwidth")]
+    border_width: Option<usize>,
+}
+
+impl RangeSelector {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct SelectorButton {
+    visible: Option<bool>,
+    step: Option<SelectorStep>,
+    #[serde(rename = "stepmode")]
+    step_mode: Option<StepMode>,
+    count: Option<usize>,
+    label: Option<String>,
+    name: Option<String>,
+    #[serde(rename = "templateitemname")]
+    template_item_name: Option<String>,
+}
+
+impl SelectorButton {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum SelectorStep {
+    Month,
+    Year,
+    Day,
+    Hour,
+    Minute,
+    Second,
+    All,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum StepMode {
+    Backward,
+    ToDate,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct Axis {
+    visible: Option<bool>,
+    /// Sets the order in which categories on this axis appear. Only has an
+    /// effect if `category_order` is set to [`CategoryOrder::Array`].
+    /// Used with `category_order`.
+    #[serde(rename = "categoryarray")]
+    category_array: Option<NumOrStringCollection>,
+    /// Specifies the ordering logic for the case of categorical variables.
+    /// By default, plotly uses [`CategoryOrder::Trace`], which specifies
+    /// the order that is present in the data supplied. Set `category_order` to
+    /// [`CategoryOrder::CategoryAscending`] or
+    /// [`CategoryOrder::CategoryDescending`] if order should be determined
+    /// by the alphanumerical order of the category names. Set `category_order`
+    /// to [`CategoryOrder::Array`] to derive the ordering from the attribute
+    /// `category_array`. If a category is not found in the `category_array`
+    /// array, the sorting behavior for that attribute will be identical to the
+    /// [`CategoryOrder::Trace`] mode. The unspecified categories will follow
+    /// the categories in `category_array`. Set `category_order` to
+    /// [`CategoryOrder::TotalAscending`] or
+    /// [`CategoryOrder::TotalDescending`] if order should be determined by the
+    /// numerical order of the values. Similarly, the order can be determined
+    /// by the min, max, sum, mean, geometric mean or median of all the values.
+    #[serde(rename = "categoryorder")]
+    category_order: Option<CategoryOrder>,
+    color: Option<Box<dyn Color>>,
+    title: Option<Title>,
+    #[field_setter(skip)]
+    r#type: Option<AxisType>,
+    #[serde(rename = "autorange")]
+    auto_range: Option<bool>,
+    #[serde(rename = "rangemode")]
+    range_mode: Option<RangeMode>,
+    range: Option<NumOrStringCollection>,
+    #[serde(rename = "fixedrange")]
+    fixed_range: Option<bool>,
+    constrain: Option<AxisConstrain>,
+    #[serde(rename = "constraintoward")]
+    constrain_toward: Option<ConstrainDirection>,
+    #[serde(rename = "tickmode")]
+    tick_mode: Option<TickMode>,
+    #[serde(rename = "nticks")]
+    n_ticks: Option<usize>,
+
+    #[serde(rename = "scaleanchor")]
+    scale_anchor: Option<String>,
+    #[serde(rename = "scaleratio")]
+    scale_ratio: Option<f64>,
+
+    tick0: Option<f64>,
+    dtick: Option<f64>,
+
+    #[field_setter(skip)]
+    matches: Option<String>,
+
+    #[serde(rename = "tickvals")]
+    tick_values: Option<Vec<f64>>,
+    #[serde(rename = "ticktext")]
+    tick_text: Option<Vec<String>>,
+    ticks: Option<TicksDirection>,
+    #[serde(rename = "tickson")]
+    ticks_on: Option<TicksPosition>,
+    mirror: Option<bool>,
+    #[serde(rename = "ticklen")]
+    tick_length: Option<usize>,
+    #[serde(rename = "tickwidth")]
+    tick_width: Option<usize>,
+    #[serde(rename = "tickcolor")]
+    tick_color: Option<Box<dyn Color>>,
+    #[serde(rename = "showticklabels")]
+    show_tick_labels: Option<bool>,
+    #[serde(rename = "automargin")]
+    auto_margin: Option<bool>,
+    #[serde(rename = "showspikes")]
+    show_spikes: Option<bool>,
+    #[serde(rename = "spikecolor")]
+    spike_color: Option<Box<dyn Color>>,
+    #[serde(rename = "spikethickness")]
+    spike_thickness: Option<usize>,
+    #[serde(rename = "spikedash")]
+    spike_dash: Option<DashType>,
+    #[serde(rename = "spikemode")]
+    spike_mode: Option<SpikeMode>,
+    #[serde(rename = "spikesnap")]
+    spike_snap: Option<SpikeSnap>,
+    #[serde(rename = "tickfont")]
+    tick_font: Option<Font>,
+    #[serde(rename = "tickangle")]
+    tick_angle: Option<f64>,
+    #[serde(rename = "tickprefix")]
+    tick_prefix: Option<String>,
+    #[serde(rename = "showtickprefix")]
+    show_tick_prefix: Option<ArrayShow>,
+    #[serde(rename = "ticksuffix")]
+    tick_suffix: Option<String>,
+    #[serde(rename = "showticksuffix")]
+    show_tick_suffix: Option<ArrayShow>,
+    #[serde(rename = "showexponent")]
+    show_exponent: Option<ArrayShow>,
+    #[serde(rename = "exponentformat")]
+    exponent_format: Option<ExponentFormat>,
+    #[serde(rename = "separatethousands")]
+    separate_thousands: Option<bool>,
+    #[serde(rename = "tickformat")]
+    tick_format: Option<String>,
+    #[serde(rename = "tickformatstops")]
+    tick_format_stops: Option<Vec<TickFormatStop>>,
+    #[serde(rename = "hoverformat")]
+    hover_format: Option<String>,
+    #[serde(rename = "showline")]
+    show_line: Option<bool>,
+    #[serde(rename = "linecolor")]
+    line_color: Option<Box<dyn Color>>,
+    #[serde(rename = "linewidth")]
+    line_width: Option<usize>,
+    #[serde(rename = "showgrid")]
+    show_grid: Option<bool>,
+    #[serde(rename = "gridcolor")]
+    grid_color: Option<Box<dyn Color>>,
+    #[serde(rename = "gridwidth")]
+    grid_width: Option<usize>,
+    #[serde(rename = "zeroline")]
+    zero_line: Option<bool>,
+    #[serde(rename = "zerolinecolor")]
+    zero_line_color: Option<Box<dyn Color>>,
+    #[serde(rename = "zerolinewidth")]
+    zero_line_width: Option<usize>,
+    #[serde(rename = "showdividers")]
+    show_dividers: Option<bool>,
+    #[serde(rename = "dividercolor")]
+    divider_color: Option<Box<dyn Color>>,
+    #[serde(rename = "dividerwidth")]
+    divider_width: Option<usize>,
+    anchor: Option<String>,
+    side: Option<AxisSide>,
+    overlaying: Option<String>,
+    #[field_setter(skip)]
+    domain: Option<Vec<f64>>,
+    position: Option<f64>,
+    #[serde(rename = "rangeslider")]
+    range_slider: Option<RangeSlider>,
+    #[serde(rename = "rangeselector")]
+    range_selector: Option<RangeSelector>,
+    calendar: Option<Calendar>,
+}
+
+impl Axis {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn matches(mut self, matches: &str) -> Self {
+        self.matches = Some(matches.to_string());
+        self
+    }
+
+    pub fn type_(mut self, t: AxisType) -> Self {
+        self.r#type = Some(t);
+        self
+    }
+
+    pub fn domain(mut self, domain: &[f64]) -> Self {
+        self.domain = Some(domain.to_vec());
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_range_mode() {
+        assert_eq!(to_value(RangeMode::Normal).unwrap(), json!("normal"));
+        assert_eq!(to_value(RangeMode::ToZero).unwrap(), json!("tozero"));
+        assert_eq!(to_value(RangeMode::NonNegative).unwrap(), json!("nonnegative"));
+    }
+
+    #[test]
+    fn serialize_ticks_direction() {
+        assert_eq!(to_value(TicksDirection::Outside).unwrap(), json!("outside"));
+        assert_eq!(to_value(TicksDirection::Inside).unwrap(), json!("inside"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_ticks_position() {
+        assert_eq!(to_value(TicksPosition::Labels).unwrap(), json!("labels"));
+        assert_eq!(to_value(TicksPosition::Boundaries).unwrap(), json!("boundaries"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_category_order() {
+        assert_eq!(to_value(CategoryOrder::Trace).unwrap(), json!("trace"));
+        assert_eq!(to_value(CategoryOrder::CategoryAscending).unwrap(), json!("category ascending"));
+        assert_eq!(to_value(CategoryOrder::CategoryDescending).unwrap(), json!("category descending"));
+        assert_eq!(to_value(CategoryOrder::Array).unwrap(), json!("array"));
+        assert_eq!(to_value(CategoryOrder::TotalAscending).unwrap(), json!("total ascending"));
+        assert_eq!(to_value(CategoryOrder::TotalDescending).unwrap(), json!("total descending"));
+        assert_eq!(to_value(CategoryOrder::MinAscending).unwrap(), json!("min ascending"));
+        assert_eq!(to_value(CategoryOrder::MinDescending).unwrap(), json!("min descending"));
+        assert_eq!(to_value(CategoryOrder::MaxAscending).unwrap(), json!("max ascending"));
+        assert_eq!(to_value(CategoryOrder::MaxDescending).unwrap(), json!("max descending"));
+        assert_eq!(to_value(CategoryOrder::SumAscending).unwrap(), json!("sum ascending"));
+        assert_eq!(to_value(CategoryOrder::SumDescending).unwrap(), json!("sum descending"));
+        assert_eq!(to_value(CategoryOrder::MeanAscending).unwrap(), json!("mean ascending"));
+        assert_eq!(to_value(CategoryOrder::MeanDescending).unwrap(), json!("mean descending"));
+        assert_eq!(to_value(CategoryOrder::GeometricMeanAscending).unwrap(), json!("geometric mean ascending"));
+        assert_eq!(to_value(CategoryOrder::GeometricMeanDescending).unwrap(), json!("geometric mean descending"));
+        assert_eq!(to_value(CategoryOrder::MedianAscending).unwrap(), json!("median ascending"));
+        assert_eq!(to_value(CategoryOrder::MedianDescending).unwrap(), json!("median descending"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_axis_side() {
+        assert_eq!(to_value(AxisSide::Left).unwrap(), json!("left"));
+        assert_eq!(to_value(AxisSide::Top).unwrap(), json!("top"));
+        assert_eq!(to_value(AxisSide::Right).unwrap(), json!("right"));
+        assert_eq!(to_value(AxisSide::Bottom).unwrap(), json!("bottom"));
+    }
+
+    #[test]
+    fn serialize_selector_step() {
+        assert_eq!(to_value(SelectorStep::Month).unwrap(), json!("month"));
+        assert_eq!(to_value(SelectorStep::Year).unwrap(), json!("year"));
+        assert_eq!(to_value(SelectorStep::Day).unwrap(), json!("day"));
+        assert_eq!(to_value(SelectorStep::Hour).unwrap(), json!("hour"));
+        assert_eq!(to_value(SelectorStep::Minute).unwrap(), json!("minute"));
+        assert_eq!(to_value(SelectorStep::Second).unwrap(), json!("second"));
+        assert_eq!(to_value(SelectorStep::All).unwrap(), json!("all"));
+    }
+
+    #[test]
+    fn serialize_step_mode() {
+        assert_eq!(to_value(StepMode::Backward).unwrap(), json!("backward"));
+        assert_eq!(to_value(StepMode::ToDate).unwrap(), json!("todate"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_spike_mode() {
+        assert_eq!(to_value(SpikeMode::ToAxis).unwrap(), json!("toaxis"));
+        assert_eq!(to_value(SpikeMode::Across).unwrap(), json!("across"));
+        assert_eq!(to_value(SpikeMode::Marker).unwrap(), json!("marker"));
+        assert_eq!(to_value(SpikeMode::ToaxisAcross).unwrap(), json!("toaxis+across"));
+        assert_eq!(to_value(SpikeMode::ToAxisMarker).unwrap(), json!("toaxis+marker"));
+        assert_eq!(to_value(SpikeMode::AcrossMarker).unwrap(), json!("across+marker"));
+        assert_eq!(to_value(SpikeMode::ToaxisAcrossMarker).unwrap(), json!("toaxis+across+marker"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_spike_snap() {
+        assert_eq!(to_value(SpikeSnap::Data).unwrap(), json!("data"));
+        assert_eq!(to_value(SpikeSnap::Cursor).unwrap(), json!("cursor"));
+        assert_eq!(to_value(SpikeSnap::HoveredData).unwrap(), json!("hovered data"));
+    }
+
+    #[test]
+    fn serialize_selector_button() {
+        let selector_button = SelectorButton::new()
+            .visible(false)
+            .step(SelectorStep::Hour)
+            .step_mode(StepMode::ToDate)
+            .count(42)
+            .label("label")
+            .name("name")
+            .template_item_name("something");
+
+        let expected = json!({
+            "visible": false,
+            "step": "hour",
+            "stepmode": "todate",
+            "count": 42,
+            "label": "label",
+            "name": "name",
+            "templateitemname": "something",
+        });
+
+        assert_eq!(to_value(selector_button).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_range_selector() {
+        let range_selector = RangeSelector::new()
+            .visible(true)
+            .buttons(vec![SelectorButton::new()])
+            .x(2.0)
+            .x_anchor(Anchor::Middle)
+            .y(4.0)
+            .y_anchor(Anchor::Top)
+            .font(Font::new())
+            .background_color("#123ABC")
+            .border_color("#ABC123")
+            .border_width(1000)
+            .active_color("#888999");
+
+        let expected = json!({
+            "visible": true,
+            "buttons": [{}],
+            "x": 2.0,
+            "xanchor": "middle",
+            "y": 4.0,
+            "yanchor": "top",
+            "font": {},
+            "bgcolor": "#123ABC",
+            "bordercolor": "#ABC123",
+            "borderwidth": 1000,
+            "activecolor": "#888999",
+        });
+
+        assert_eq!(to_value(range_selector).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_range_slider() {
+        let range_slider = RangeSlider::new()
+            .background_color("#123ABC")
+            .border_color("#ABC123")
+            .border_width(1000)
+            .auto_range(false)
+            .range(vec![5_i32])
+            .thickness(2000.)
+            .visible(true)
+            .y_axis(RangeSliderYAxis::new());
+
+        let expected = json!({
+            "bgcolor": "#123ABC",
+            "bordercolor": "#ABC123",
+            "borderwidth": 1000,
+            "autorange": false,
+            "range": [5],
+            "thickness": 2000.0,
+            "visible": true,
+            "yaxis": {}
+        });
+
+        assert_eq!(to_value(range_slider).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_range_slider_y_axis() {
+        let range_slider_y_axis = RangeSliderYAxis::new()
+            .range_mode(SliderRangeMode::Match)
+            .range(vec![0.2]);
+        let expected = json!({
+            "rangemode": "match",
+            "range": [0.2]
+        });
+
+        assert_eq!(to_value(range_slider_y_axis).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_slider_range_mode() {
+        assert_eq!(to_value(SliderRangeMode::Auto).unwrap(), json!("auto"));
+        assert_eq!(to_value(SliderRangeMode::Fixed).unwrap(), json!("fixed"));
+        assert_eq!(to_value(SliderRangeMode::Match).unwrap(), json!("match"));
+    }
+
+    #[test]
+    fn serialize_axis() {
+        let axis = Axis::new()
+            .visible(false)
+            .color("#678123")
+            .title(Title::with_text("title"))
+            .type_(AxisType::Date)
+            .auto_range(false)
+            .range_mode(RangeMode::NonNegative)
+            .range(vec![2.0])
+            .fixed_range(true)
+            .constrain(AxisConstrain::Range)
+            .constrain_toward(ConstrainDirection::Middle)
+            .tick_mode(TickMode::Auto)
+            .n_ticks(600)
+            .tick0(5.0)
+            .dtick(10.0)
+            .matches("x")
+            .tick_values(vec![1.0, 2.0])
+            .tick_text(vec!["one".to_string(), "two".to_string()])
+            .ticks(TicksDirection::Inside)
+            .ticks_on(TicksPosition::Boundaries)
+            .mirror(false)
+            .tick_length(77)
+            .tick_width(99)
+            .tick_color("#101010")
+            .show_tick_labels(false)
+            .auto_margin(true)
+            .show_spikes(false)
+            .spike_color("#ABABAB")
+            .spike_thickness(501)
+            .spike_dash(DashType::DashDot)
+            .spike_mode(SpikeMode::AcrossMarker)
+            .spike_snap(SpikeSnap::Data)
+            .tick_font(Font::new())
+            .tick_angle(2.1)
+            .tick_prefix("prefix")
+            .show_tick_prefix(ArrayShow::Last)
+            .tick_suffix("suffix")
+            .show_tick_suffix(ArrayShow::None)
+            .show_exponent(ArrayShow::All)
+            .exponent_format(ExponentFormat::SmallE)
+            .separate_thousands(false)
+            .tick_format("tickfmt")
+            .tick_format_stops(vec![TickFormatStop::new()])
+            .hover_format("hoverfmt")
+            .show_line(true)
+            .line_color("#CCCDDD")
+            .line_width(9)
+            .show_grid(false)
+            .grid_color("#fff000")
+            .grid_width(8)
+            .zero_line(true)
+            .zero_line_color("#f0f0f0")
+            .zero_line_width(7)
+            .show_dividers(false)
+            .divider_color("#AFAFAF")
+            .divider_width(55)
+            .anchor("anchor")
+            .side(AxisSide::Right)
+            .overlaying("overlaying")
+            .domain(&[0.0, 1.0])
+            .position(0.6)
+            .range_slider(RangeSlider::new())
+            .range_selector(RangeSelector::new())
+            .calendar(Calendar::Coptic)
+            .category_order(CategoryOrder::Array)
+            .category_array(vec!["Category0", "Category1"]);
+
+        let expected = json!({
+            "visible": false,
+            "color": "#678123",
+            "title": {"text": "title"},
+            "type": "date",
+            "autorange": false,
+            "rangemode": "nonnegative",
+            "range": [2.0],
+            "fixedrange": true,
+            "constrain": "range",
+            "constraintoward": "middle",
+            "tickmode": "auto",
+            "nticks": 600,
+            "tick0": 5.0,
+            "dtick": 10.0,
+            "matches": "x",
+            "tickvals": [1.0, 2.0],
+            "ticktext": ["one", "two"],
+            "ticks": "inside",
+            "tickson": "boundaries",
+            "mirror": false,
+            "ticklen": 77,
+            "tickwidth": 99,
+            "tickcolor": "#101010",
+            "showticklabels": false,
+            "automargin": true,
+            "showspikes": false,
+            "spikecolor": "#ABABAB",
+            "spikethickness": 501,
+            "spikedash": "dashdot",
+            "spikemode": "across+marker",
+            "spikesnap": "data",
+            "tickfont": {},
+            "tickangle": 2.1,
+            "tickprefix": "prefix",
+            "showtickprefix": "last",
+            "ticksuffix": "suffix",
+            "showticksuffix": "none",
+            "showexponent": "all",
+            "exponentformat": "e",
+            "separatethousands": false,
+            "tickformat": "tickfmt",
+            "tickformatstops": [{"enabled": true}],
+            "hoverformat": "hoverfmt",
+            "showline": true,
+            "linecolor": "#CCCDDD",
+            "linewidth": 9,
+            "showgrid": false,
+            "gridcolor": "#fff000",
+            "gridwidth": 8,
+            "zeroline": true,
+            "zerolinecolor": "#f0f0f0",
+            "zerolinewidth": 7,
+            "showdividers": false,
+            "dividercolor": "#AFAFAF",
+            "dividerwidth": 55,
+            "anchor": "anchor",
+            "side": "right",
+            "overlaying": "overlaying",
+            "domain": [0.0, 1.0],
+            "position": 0.6,
+            "rangeslider": {},
+            "rangeselector": {},
+            "calendar": "coptic",
+            "categoryorder": "array",
+            "categoryarray": ["Category0", "Category1"]
+        });
+
+        assert_eq!(to_value(axis).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index 33cf54b2..b0c7a618 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -1,87 +1,27 @@
 pub mod themes;
 pub mod update_menu;
 
-// Re-export moved types
 mod annotation;
-pub use self::annotation::{Annotation, ArrowSide, ClickToShow, HAlign, VAlign};
-
+mod axis;
+// Re-export separated module types
 use std::borrow::Cow;
 
 use plotly_derive::FieldSetter;
 use serde::{Serialize, Serializer};
 use update_menu::UpdateMenu;
 
+pub use self::annotation::{Annotation, ArrowSide, ClickToShow, HAlign, VAlign};
+pub use self::axis::{
+    ArrayShow, Axis, AxisConstrain, AxisType, CategoryOrder, ConstrainDirection, TicksDirection,
+    TicksPosition,
+};
 use crate::common::Domain;
 use crate::{
     color::Color,
-    common::{
-        Anchor, AxisSide, Calendar, ColorBar, ColorScale, DashType, ExponentFormat, Font, Label,
-        Orientation, TickFormatStop, TickMode, Title,
-    },
-    private::{NumOrString, NumOrStringCollection},
+    common::{Anchor, Calendar, ColorBar, ColorScale, DashType, Font, Label, Orientation, Title},
+    private::NumOrString,
 };
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum AxisType {
-    #[serde(rename = "-")]
-    Default,
-    Linear,
-    Log,
-    Date,
-    Category,
-    MultiCategory,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum AxisConstrain {
-    Range,
-    Domain,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ConstrainDirection {
-    Left,
-    Center,
-    Right,
-    Top,
-    Middle,
-    Bottom,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum RangeMode {
-    Normal,
-    ToZero,
-    NonNegative,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum TicksDirection {
-    Outside,
-    Inside,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum TicksPosition {
-    Labels,
-    Boundaries,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ArrayShow {
-    All,
-    First,
-    Last,
-    None,
-}
-
 #[derive(Serialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum BarMode {
@@ -243,119 +183,6 @@ impl LayoutColorScale {
     }
 }
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum SliderRangeMode {
-    Auto,
-    Fixed,
-    Match,
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct RangeSliderYAxis {
-    #[serde(rename = "rangemode")]
-    range_mode: Option<SliderRangeMode>,
-    range: Option<NumOrStringCollection>,
-}
-
-impl RangeSliderYAxis {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct RangeSlider {
-    #[serde(rename = "bgcolor")]
-    background_color: Option<Box<dyn Color>>,
-    #[serde(rename = "bordercolor")]
-    border_color: Option<Box<dyn Color>>,
-    #[serde(rename = "borderwidth")]
-    border_width: Option<u64>,
-    #[serde(rename = "autorange")]
-    auto_range: Option<bool>,
-    range: Option<NumOrStringCollection>,
-    thickness: Option<f64>,
-    visible: Option<bool>,
-    #[serde(rename = "yaxis")]
-    y_axis: Option<RangeSliderYAxis>,
-}
-
-impl RangeSlider {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum SelectorStep {
-    Month,
-    Year,
-    Day,
-    Hour,
-    Minute,
-    Second,
-    All,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum StepMode {
-    Backward,
-    ToDate,
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct SelectorButton {
-    visible: Option<bool>,
-    step: Option<SelectorStep>,
-    #[serde(rename = "stepmode")]
-    step_mode: Option<StepMode>,
-    count: Option<usize>,
-    label: Option<String>,
-    name: Option<String>,
-    #[serde(rename = "templateitemname")]
-    template_item_name: Option<String>,
-}
-
-impl SelectorButton {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct RangeSelector {
-    visible: Option<bool>,
-    buttons: Option<Vec<SelectorButton>>,
-    x: Option<f64>,
-    #[serde(rename = "xanchor")]
-    x_anchor: Option<Anchor>,
-    y: Option<f64>,
-    #[serde(rename = "yanchor")]
-    y_anchor: Option<Anchor>,
-    font: Option<Font>,
-    #[serde(rename = "bgcolor")]
-    background_color: Option<Box<dyn Color>>,
-    #[serde(rename = "activecolor")]
-    active_color: Option<Box<dyn Color>>,
-    #[serde(rename = "bordercolor")]
-    border_color: Option<Box<dyn Color>>,
-    #[serde(rename = "borderwidth")]
-    border_width: Option<usize>,
-}
-
-impl RangeSelector {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
 pub struct ColorAxis {
@@ -381,239 +208,6 @@ impl ColorAxis {
     }
 }
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum SpikeMode {
-    ToAxis,
-    Across,
-    Marker,
-    #[serde(rename = "toaxis+across")]
-    ToaxisAcross,
-    #[serde(rename = "toaxis+marker")]
-    ToAxisMarker,
-    #[serde(rename = "across+marker")]
-    AcrossMarker,
-    #[serde(rename = "toaxis+across+marker")]
-    ToaxisAcrossMarker,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum SpikeSnap {
-    Data,
-    Cursor,
-    #[serde(rename = "hovered data")]
-    HoveredData,
-}
-
-#[derive(Serialize, Debug, Clone)]
-pub enum CategoryOrder {
-    #[serde(rename = "trace")]
-    Trace,
-    #[serde(rename = "category ascending")]
-    CategoryAscending,
-    #[serde(rename = "category descending")]
-    CategoryDescending,
-    #[serde(rename = "array")]
-    Array,
-    #[serde(rename = "total ascending")]
-    TotalAscending,
-    #[serde(rename = "total descending")]
-    TotalDescending,
-    #[serde(rename = "min ascending")]
-    MinAscending,
-    #[serde(rename = "min descending")]
-    MinDescending,
-    #[serde(rename = "max ascending")]
-    MaxAscending,
-    #[serde(rename = "max descending")]
-    MaxDescending,
-    #[serde(rename = "sum ascending")]
-    SumAscending,
-    #[serde(rename = "sum descending")]
-    SumDescending,
-    #[serde(rename = "mean ascending")]
-    MeanAscending,
-    #[serde(rename = "mean descending")]
-    MeanDescending,
-    #[serde(rename = "geometric mean ascending")]
-    GeometricMeanAscending,
-    #[serde(rename = "geometric mean descending")]
-    GeometricMeanDescending,
-    #[serde(rename = "median ascending")]
-    MedianAscending,
-    #[serde(rename = "median descending")]
-    MedianDescending,
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct Axis {
-    visible: Option<bool>,
-    /// Sets the order in which categories on this axis appear. Only has an
-    /// effect if `category_order` is set to [`CategoryOrder::Array`].
-    /// Used with `category_order`.
-    #[serde(rename = "categoryarray")]
-    category_array: Option<NumOrStringCollection>,
-    /// Specifies the ordering logic for the case of categorical variables.
-    /// By default, plotly uses [`CategoryOrder::Trace`], which specifies
-    /// the order that is present in the data supplied. Set `category_order` to
-    /// [`CategoryOrder::CategoryAscending`] or
-    /// [`CategoryOrder::CategoryDescending`] if order should be determined
-    /// by the alphanumerical order of the category names. Set `category_order`
-    /// to [`CategoryOrder::Array`] to derive the ordering from the attribute
-    /// `category_array`. If a category is not found in the `category_array`
-    /// array, the sorting behavior for that attribute will be identical to the
-    /// [`CategoryOrder::Trace`] mode. The unspecified categories will follow
-    /// the categories in `category_array`. Set `category_order` to
-    /// [`CategoryOrder::TotalAscending`] or
-    /// [`CategoryOrder::TotalDescending`] if order should be determined by the
-    /// numerical order of the values. Similarly, the order can be determined
-    /// by the min, max, sum, mean, geometric mean or median of all the values.
-    #[serde(rename = "categoryorder")]
-    category_order: Option<CategoryOrder>,
-    color: Option<Box<dyn Color>>,
-    title: Option<Title>,
-    #[field_setter(skip)]
-    r#type: Option<AxisType>,
-    #[serde(rename = "autorange")]
-    auto_range: Option<bool>,
-    #[serde(rename = "rangemode")]
-    range_mode: Option<RangeMode>,
-    range: Option<NumOrStringCollection>,
-    #[serde(rename = "fixedrange")]
-    fixed_range: Option<bool>,
-    constrain: Option<AxisConstrain>,
-    #[serde(rename = "constraintoward")]
-    constrain_toward: Option<ConstrainDirection>,
-    #[serde(rename = "tickmode")]
-    tick_mode: Option<TickMode>,
-    #[serde(rename = "nticks")]
-    n_ticks: Option<usize>,
-
-    #[serde(rename = "scaleanchor")]
-    scale_anchor: Option<String>,
-    #[serde(rename = "scaleratio")]
-    scale_ratio: Option<f64>,
-
-    tick0: Option<f64>,
-    dtick: Option<f64>,
-
-    #[field_setter(skip)]
-    matches: Option<String>,
-
-    #[serde(rename = "tickvals")]
-    tick_values: Option<Vec<f64>>,
-    #[serde(rename = "ticktext")]
-    tick_text: Option<Vec<String>>,
-    ticks: Option<TicksDirection>,
-    #[serde(rename = "tickson")]
-    ticks_on: Option<TicksPosition>,
-    mirror: Option<bool>,
-    #[serde(rename = "ticklen")]
-    tick_length: Option<usize>,
-    #[serde(rename = "tickwidth")]
-    tick_width: Option<usize>,
-    #[serde(rename = "tickcolor")]
-    tick_color: Option<Box<dyn Color>>,
-    #[serde(rename = "showticklabels")]
-    show_tick_labels: Option<bool>,
-    #[serde(rename = "automargin")]
-    auto_margin: Option<bool>,
-    #[serde(rename = "showspikes")]
-    show_spikes: Option<bool>,
-    #[serde(rename = "spikecolor")]
-    spike_color: Option<Box<dyn Color>>,
-    #[serde(rename = "spikethickness")]
-    spike_thickness: Option<usize>,
-    #[serde(rename = "spikedash")]
-    spike_dash: Option<DashType>,
-    #[serde(rename = "spikemode")]
-    spike_mode: Option<SpikeMode>,
-    #[serde(rename = "spikesnap")]
-    spike_snap: Option<SpikeSnap>,
-    #[serde(rename = "tickfont")]
-    tick_font: Option<Font>,
-    #[serde(rename = "tickangle")]
-    tick_angle: Option<f64>,
-    #[serde(rename = "tickprefix")]
-    tick_prefix: Option<String>,
-    #[serde(rename = "showtickprefix")]
-    show_tick_prefix: Option<ArrayShow>,
-    #[serde(rename = "ticksuffix")]
-    tick_suffix: Option<String>,
-    #[serde(rename = "showticksuffix")]
-    show_tick_suffix: Option<ArrayShow>,
-    #[serde(rename = "showexponent")]
-    show_exponent: Option<ArrayShow>,
-    #[serde(rename = "exponentformat")]
-    exponent_format: Option<ExponentFormat>,
-    #[serde(rename = "separatethousands")]
-    separate_thousands: Option<bool>,
-    #[serde(rename = "tickformat")]
-    tick_format: Option<String>,
-    #[serde(rename = "tickformatstops")]
-    tick_format_stops: Option<Vec<TickFormatStop>>,
-    #[serde(rename = "hoverformat")]
-    hover_format: Option<String>,
-    #[serde(rename = "showline")]
-    show_line: Option<bool>,
-    #[serde(rename = "linecolor")]
-    line_color: Option<Box<dyn Color>>,
-    #[serde(rename = "linewidth")]
-    line_width: Option<usize>,
-    #[serde(rename = "showgrid")]
-    show_grid: Option<bool>,
-    #[serde(rename = "gridcolor")]
-    grid_color: Option<Box<dyn Color>>,
-    #[serde(rename = "gridwidth")]
-    grid_width: Option<usize>,
-    #[serde(rename = "zeroline")]
-    zero_line: Option<bool>,
-    #[serde(rename = "zerolinecolor")]
-    zero_line_color: Option<Box<dyn Color>>,
-    #[serde(rename = "zerolinewidth")]
-    zero_line_width: Option<usize>,
-    #[serde(rename = "showdividers")]
-    show_dividers: Option<bool>,
-    #[serde(rename = "dividercolor")]
-    divider_color: Option<Box<dyn Color>>,
-    #[serde(rename = "dividerwidth")]
-    divider_width: Option<usize>,
-    anchor: Option<String>,
-    side: Option<AxisSide>,
-    overlaying: Option<String>,
-    #[field_setter(skip)]
-    domain: Option<Vec<f64>>,
-    position: Option<f64>,
-    #[serde(rename = "rangeslider")]
-    range_slider: Option<RangeSlider>,
-    #[serde(rename = "rangeselector")]
-    range_selector: Option<RangeSelector>,
-    calendar: Option<Calendar>,
-}
-
-impl Axis {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn matches(mut self, matches: &str) -> Self {
-        self.matches = Some(matches.to_string());
-        self
-    }
-
-    pub fn type_(mut self, t: AxisType) -> Self {
-        self.r#type = Some(t);
-        self
-    }
-
-    pub fn domain(mut self, domain: &[f64]) -> Self {
-        self.domain = Some(domain.to_vec());
-        self
-    }
-}
-
 #[derive(Serialize, Debug, Clone)]
 pub enum RowOrder {
     #[serde(rename = "top to bottom")]
@@ -1857,27 +1451,6 @@ mod tests {
         assert_eq!(to_value(ConstrainDirection::Bottom).unwrap(), json!("bottom"));
     }
 
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_range_mode() {
-        assert_eq!(to_value(RangeMode::Normal).unwrap(), json!("normal"));
-        assert_eq!(to_value(RangeMode::ToZero).unwrap(), json!("tozero"));
-        assert_eq!(to_value(RangeMode::NonNegative).unwrap(), json!("nonnegative"));
-    }
-
-    #[test]
-    fn serialize_ticks_direction() {
-        assert_eq!(to_value(TicksDirection::Outside).unwrap(), json!("outside"));
-        assert_eq!(to_value(TicksDirection::Inside).unwrap(), json!("inside"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_ticks_position() {
-        assert_eq!(to_value(TicksPosition::Labels).unwrap(), json!("labels"));
-        assert_eq!(to_value(TicksPosition::Boundaries).unwrap(), json!("boundaries"));
-    }
-
     #[test]
     fn serialize_array_show() {
         assert_eq!(to_value(ArrayShow::All).unwrap(), json!("all"));
@@ -2031,168 +1604,6 @@ mod tests {
         assert_eq!(to_value(layout_color_scale).unwrap(), expected);
     }
 
-    #[test]
-    fn serialize_slider_range_mode() {
-        assert_eq!(to_value(SliderRangeMode::Auto).unwrap(), json!("auto"));
-        assert_eq!(to_value(SliderRangeMode::Fixed).unwrap(), json!("fixed"));
-        assert_eq!(to_value(SliderRangeMode::Match).unwrap(), json!("match"));
-    }
-
-    #[test]
-    fn serialize_range_slider_y_axis() {
-        let range_slider_y_axis = RangeSliderYAxis::new()
-            .range_mode(SliderRangeMode::Match)
-            .range(vec![0.2]);
-        let expected = json!({
-            "rangemode": "match",
-            "range": [0.2]
-        });
-
-        assert_eq!(to_value(range_slider_y_axis).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_range_slider() {
-        let range_slider = RangeSlider::new()
-            .background_color("#123ABC")
-            .border_color("#ABC123")
-            .border_width(1000)
-            .auto_range(false)
-            .range(vec![5_i32])
-            .thickness(2000.)
-            .visible(true)
-            .y_axis(RangeSliderYAxis::new());
-
-        let expected = json!({
-            "bgcolor": "#123ABC",
-            "bordercolor": "#ABC123",
-            "borderwidth": 1000,
-            "autorange": false,
-            "range": [5],
-            "thickness": 2000.0,
-            "visible": true,
-            "yaxis": {}
-        });
-
-        assert_eq!(to_value(range_slider).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_selector_step() {
-        assert_eq!(to_value(SelectorStep::Month).unwrap(), json!("month"));
-        assert_eq!(to_value(SelectorStep::Year).unwrap(), json!("year"));
-        assert_eq!(to_value(SelectorStep::Day).unwrap(), json!("day"));
-        assert_eq!(to_value(SelectorStep::Hour).unwrap(), json!("hour"));
-        assert_eq!(to_value(SelectorStep::Minute).unwrap(), json!("minute"));
-        assert_eq!(to_value(SelectorStep::Second).unwrap(), json!("second"));
-        assert_eq!(to_value(SelectorStep::All).unwrap(), json!("all"));
-    }
-
-    #[test]
-    fn serialize_step_mode() {
-        assert_eq!(to_value(StepMode::Backward).unwrap(), json!("backward"));
-        assert_eq!(to_value(StepMode::ToDate).unwrap(), json!("todate"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_spike_mode() {
-        assert_eq!(to_value(SpikeMode::ToAxis).unwrap(), json!("toaxis"));
-        assert_eq!(to_value(SpikeMode::Across).unwrap(), json!("across"));
-        assert_eq!(to_value(SpikeMode::Marker).unwrap(), json!("marker"));
-        assert_eq!(to_value(SpikeMode::ToaxisAcross).unwrap(), json!("toaxis+across"));
-        assert_eq!(to_value(SpikeMode::ToAxisMarker).unwrap(), json!("toaxis+marker"));
-        assert_eq!(to_value(SpikeMode::AcrossMarker).unwrap(), json!("across+marker"));
-        assert_eq!(to_value(SpikeMode::ToaxisAcrossMarker).unwrap(), json!("toaxis+across+marker"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_spike_snap() {
-        assert_eq!(to_value(SpikeSnap::Data).unwrap(), json!("data"));
-        assert_eq!(to_value(SpikeSnap::Cursor).unwrap(), json!("cursor"));
-        assert_eq!(to_value(SpikeSnap::HoveredData).unwrap(), json!("hovered data"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_category_order() {
-        assert_eq!(to_value(CategoryOrder::Trace).unwrap(), json!("trace"));
-        assert_eq!(to_value(CategoryOrder::CategoryAscending).unwrap(), json!("category ascending"));
-        assert_eq!(to_value(CategoryOrder::CategoryDescending).unwrap(), json!("category descending"));
-        assert_eq!(to_value(CategoryOrder::Array).unwrap(), json!("array"));
-        assert_eq!(to_value(CategoryOrder::TotalAscending).unwrap(), json!("total ascending"));
-        assert_eq!(to_value(CategoryOrder::TotalDescending).unwrap(), json!("total descending"));
-        assert_eq!(to_value(CategoryOrder::MinAscending).unwrap(), json!("min ascending"));
-        assert_eq!(to_value(CategoryOrder::MinDescending).unwrap(), json!("min descending"));
-        assert_eq!(to_value(CategoryOrder::MaxAscending).unwrap(), json!("max ascending"));
-        assert_eq!(to_value(CategoryOrder::MaxDescending).unwrap(), json!("max descending"));
-        assert_eq!(to_value(CategoryOrder::SumAscending).unwrap(), json!("sum ascending"));
-        assert_eq!(to_value(CategoryOrder::SumDescending).unwrap(), json!("sum descending"));
-        assert_eq!(to_value(CategoryOrder::MeanAscending).unwrap(), json!("mean ascending"));
-        assert_eq!(to_value(CategoryOrder::MeanDescending).unwrap(), json!("mean descending"));
-        assert_eq!(to_value(CategoryOrder::GeometricMeanAscending).unwrap(), json!("geometric mean ascending"));
-        assert_eq!(to_value(CategoryOrder::GeometricMeanDescending).unwrap(), json!("geometric mean descending"));
-        assert_eq!(to_value(CategoryOrder::MedianAscending).unwrap(), json!("median ascending"));
-        assert_eq!(to_value(CategoryOrder::MedianDescending).unwrap(), json!("median descending"));
-    }
-
-    #[test]
-    fn serialize_selector_button() {
-        let selector_button = SelectorButton::new()
-            .visible(false)
-            .step(SelectorStep::Hour)
-            .step_mode(StepMode::ToDate)
-            .count(42)
-            .label("label")
-            .name("name")
-            .template_item_name("something");
-
-        let expected = json!({
-            "visible": false,
-            "step": "hour",
-            "stepmode": "todate",
-            "count": 42,
-            "label": "label",
-            "name": "name",
-            "templateitemname": "something",
-        });
-
-        assert_eq!(to_value(selector_button).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_range_selector() {
-        let range_selector = RangeSelector::new()
-            .visible(true)
-            .buttons(vec![SelectorButton::new()])
-            .x(2.0)
-            .x_anchor(Anchor::Middle)
-            .y(4.0)
-            .y_anchor(Anchor::Top)
-            .font(Font::new())
-            .background_color("#123ABC")
-            .border_color("#ABC123")
-            .border_width(1000)
-            .active_color("#888999");
-
-        let expected = json!({
-            "visible": true,
-            "buttons": [{}],
-            "x": 2.0,
-            "xanchor": "middle",
-            "y": 4.0,
-            "yanchor": "top",
-            "font": {},
-            "bgcolor": "#123ABC",
-            "bordercolor": "#ABC123",
-            "borderwidth": 1000,
-            "activecolor": "#888999",
-        });
-
-        assert_eq!(to_value(range_selector).unwrap(), expected);
-    }
-
     #[test]
     fn serialize_color_axis() {
         let color_axis = ColorAxis::new()
@@ -2221,146 +1632,6 @@ mod tests {
         assert_eq!(to_value(color_axis).unwrap(), expected);
     }
 
-    #[test]
-    fn serialize_axis() {
-        let axis = Axis::new()
-            .visible(false)
-            .color("#678123")
-            .title(Title::with_text("title"))
-            .type_(AxisType::Date)
-            .auto_range(false)
-            .range_mode(RangeMode::NonNegative)
-            .range(vec![2.0])
-            .fixed_range(true)
-            .constrain(AxisConstrain::Range)
-            .constrain_toward(ConstrainDirection::Middle)
-            .tick_mode(TickMode::Auto)
-            .n_ticks(600)
-            .tick0(5.0)
-            .dtick(10.0)
-            .matches("x")
-            .tick_values(vec![1.0, 2.0])
-            .tick_text(vec!["one".to_string(), "two".to_string()])
-            .ticks(TicksDirection::Inside)
-            .ticks_on(TicksPosition::Boundaries)
-            .mirror(false)
-            .tick_length(77)
-            .tick_width(99)
-            .tick_color("#101010")
-            .show_tick_labels(false)
-            .auto_margin(true)
-            .show_spikes(false)
-            .spike_color("#ABABAB")
-            .spike_thickness(501)
-            .spike_dash(DashType::DashDot)
-            .spike_mode(SpikeMode::AcrossMarker)
-            .spike_snap(SpikeSnap::Data)
-            .tick_font(Font::new())
-            .tick_angle(2.1)
-            .tick_prefix("prefix")
-            .show_tick_prefix(ArrayShow::Last)
-            .tick_suffix("suffix")
-            .show_tick_suffix(ArrayShow::None)
-            .show_exponent(ArrayShow::All)
-            .exponent_format(ExponentFormat::SmallE)
-            .separate_thousands(false)
-            .tick_format("tickfmt")
-            .tick_format_stops(vec![TickFormatStop::new()])
-            .hover_format("hoverfmt")
-            .show_line(true)
-            .line_color("#CCCDDD")
-            .line_width(9)
-            .show_grid(false)
-            .grid_color("#fff000")
-            .grid_width(8)
-            .zero_line(true)
-            .zero_line_color("#f0f0f0")
-            .zero_line_width(7)
-            .show_dividers(false)
-            .divider_color("#AFAFAF")
-            .divider_width(55)
-            .anchor("anchor")
-            .side(AxisSide::Right)
-            .overlaying("overlaying")
-            .domain(&[0.0, 1.0])
-            .position(0.6)
-            .range_slider(RangeSlider::new())
-            .range_selector(RangeSelector::new())
-            .calendar(Calendar::Coptic)
-            .category_order(CategoryOrder::Array)
-            .category_array(vec!["Category0", "Category1"]);
-
-        let expected = json!({
-            "visible": false,
-            "color": "#678123",
-            "title": {"text": "title"},
-            "type": "date",
-            "autorange": false,
-            "rangemode": "nonnegative",
-            "range": [2.0],
-            "fixedrange": true,
-            "constrain": "range",
-            "constraintoward": "middle",
-            "tickmode": "auto",
-            "nticks": 600,
-            "tick0": 5.0,
-            "dtick": 10.0,
-            "matches": "x",
-            "tickvals": [1.0, 2.0],
-            "ticktext": ["one", "two"],
-            "ticks": "inside",
-            "tickson": "boundaries",
-            "mirror": false,
-            "ticklen": 77,
-            "tickwidth": 99,
-            "tickcolor": "#101010",
-            "showticklabels": false,
-            "automargin": true,
-            "showspikes": false,
-            "spikecolor": "#ABABAB",
-            "spikethickness": 501,
-            "spikedash": "dashdot",
-            "spikemode": "across+marker",
-            "spikesnap": "data",
-            "tickfont": {},
-            "tickangle": 2.1,
-            "tickprefix": "prefix",
-            "showtickprefix": "last",
-            "ticksuffix": "suffix",
-            "showticksuffix": "none",
-            "showexponent": "all",
-            "exponentformat": "e",
-            "separatethousands": false,
-            "tickformat": "tickfmt",
-            "tickformatstops": [{"enabled": true}],
-            "hoverformat": "hoverfmt",
-            "showline": true,
-            "linecolor": "#CCCDDD",
-            "linewidth": 9,
-            "showgrid": false,
-            "gridcolor": "#fff000",
-            "gridwidth": 8,
-            "zeroline": true,
-            "zerolinecolor": "#f0f0f0",
-            "zerolinewidth": 7,
-            "showdividers": false,
-            "dividercolor": "#AFAFAF",
-            "dividerwidth": 55,
-            "anchor": "anchor",
-            "side": "right",
-            "overlaying": "overlaying",
-            "domain": [0.0, 1.0],
-            "position": 0.6,
-            "rangeslider": {},
-            "rangeselector": {},
-            "calendar": "coptic",
-            "categoryorder": "array",
-            "categoryarray": ["Category0", "Category1"]
-        });
-
-        assert_eq!(to_value(axis).unwrap(), expected);
-    }
-
     #[test]
     #[rustfmt::skip]
     fn serialize_row_order() {

From 171277b99ae0def496a454284e07ce4fe8e1fddc Mon Sep 17 00:00:00 2001
From: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
Date: Wed, 4 Jun 2025 09:25:52 +0200
Subject: [PATCH 3/8] extract legend type out of mod.rs

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
---
 plotly/src/layout/annotation.rs |  31 +----
 plotly/src/layout/legend.rs     | 174 ++++++++++++++++++++++++++++
 plotly/src/layout/mod.rs        | 194 ++++++--------------------------
 3 files changed, 208 insertions(+), 191 deletions(-)
 create mode 100644 plotly/src/layout/legend.rs

diff --git a/plotly/src/layout/annotation.rs b/plotly/src/layout/annotation.rs
index cdfbcf5d..a4f24c4e 100644
--- a/plotly/src/layout/annotation.rs
+++ b/plotly/src/layout/annotation.rs
@@ -3,24 +3,9 @@ use serde::{Serialize, Serializer};
 
 use crate::color::Color;
 use crate::common::{Anchor, Font, Label};
+use crate::layout::{HAlign, VAlign};
 use crate::private::NumOrString;
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum VAlign {
-    Top,
-    Middle,
-    Bottom,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum HAlign {
-    Left,
-    Center,
-    Right,
-}
-
 #[derive(Serialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum ArrowSide {
@@ -293,20 +278,6 @@ mod tests {
     use super::*;
     use crate::common::{Anchor, Font, Label};
 
-    #[test]
-    fn serialize_valign() {
-        assert_eq!(to_value(VAlign::Top).unwrap(), json!("top"));
-        assert_eq!(to_value(VAlign::Middle).unwrap(), json!("middle"));
-        assert_eq!(to_value(VAlign::Bottom).unwrap(), json!("bottom"));
-    }
-
-    #[test]
-    fn serialize_halign() {
-        assert_eq!(to_value(HAlign::Left).unwrap(), json!("left"));
-        assert_eq!(to_value(HAlign::Center).unwrap(), json!("center"));
-        assert_eq!(to_value(HAlign::Right).unwrap(), json!("right"));
-    }
-
     #[test]
     fn serialize_click_to_show() {
         assert_eq!(to_value(ClickToShow::False).unwrap(), json!(false));
diff --git a/plotly/src/layout/legend.rs b/plotly/src/layout/legend.rs
new file mode 100644
index 00000000..57e25c02
--- /dev/null
+++ b/plotly/src/layout/legend.rs
@@ -0,0 +1,174 @@
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::color::Color;
+use crate::common::{Anchor, Font, Orientation, Title};
+use crate::layout::VAlign;
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum TraceOrder {
+    Reversed,
+    Grouped,
+    #[serde(rename = "reversed+grouped")]
+    ReversedGrouped,
+    Normal,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ItemSizing {
+    Trace,
+    Constant,
+}
+
+#[derive(Debug, Clone)]
+pub enum ItemClick {
+    Toggle,
+    ToggleOthers,
+    False,
+}
+
+impl Serialize for ItemClick {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match *self {
+            Self::Toggle => serializer.serialize_str("toggle"),
+            Self::ToggleOthers => serializer.serialize_str("toggleothers"),
+            Self::False => serializer.serialize_bool(false),
+        }
+    }
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum GroupClick {
+    ToggleItem,
+    ToggleGroup,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct Legend {
+    #[serde(rename = "bgcolor")]
+    background_color: Option<Box<dyn Color>>,
+    #[serde(rename = "bordercolor")]
+    border_color: Option<Box<dyn Color>>,
+    #[serde(rename = "borderwidth")]
+    border_width: Option<usize>,
+    font: Option<Font>,
+    orientation: Option<Orientation>,
+    #[serde(rename = "traceorder")]
+    trace_order: Option<TraceOrder>,
+    #[serde(rename = "tracegroupgap")]
+    trace_group_gap: Option<usize>,
+    #[serde(rename = "itemsizing")]
+    item_sizing: Option<ItemSizing>,
+    #[serde(rename = "itemclick")]
+    item_click: Option<ItemClick>,
+    #[serde(rename = "itemdoubleclick")]
+    item_double_click: Option<ItemClick>,
+    x: Option<f64>,
+    #[serde(rename = "xanchor")]
+    x_anchor: Option<Anchor>,
+    y: Option<f64>,
+    #[serde(rename = "yanchor")]
+    y_anchor: Option<Anchor>,
+    valign: Option<VAlign>,
+    title: Option<Title>,
+    #[serde(rename = "groupclick")]
+    group_click: Option<GroupClick>,
+    #[serde(rename = "itemwidth")]
+    item_width: Option<usize>,
+}
+
+impl Legend {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_trace_order() {
+        assert_eq!(to_value(TraceOrder::Reversed).unwrap(), json!("reversed"));
+        assert_eq!(to_value(TraceOrder::Grouped).unwrap(), json!("grouped"));
+        assert_eq!(to_value(TraceOrder::ReversedGrouped).unwrap(), json!("reversed+grouped"));
+        assert_eq!(to_value(TraceOrder::Normal).unwrap(), json!("normal"));
+    }
+
+    #[test]
+    fn serialize_item_sizing() {
+        assert_eq!(to_value(ItemSizing::Trace).unwrap(), json!("trace"));
+        assert_eq!(to_value(ItemSizing::Constant).unwrap(), json!("constant"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_item_click() {
+        assert_eq!(to_value(ItemClick::Toggle).unwrap(), json!("toggle"));
+        assert_eq!(to_value(ItemClick::ToggleOthers).unwrap(), json!("toggleothers"));
+        assert_eq!(to_value(ItemClick::False).unwrap(), json!(false));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_group_click() {
+        assert_eq!(to_value(GroupClick::ToggleItem).unwrap(), json!("toggleitem"));
+        assert_eq!(to_value(GroupClick::ToggleGroup).unwrap(), json!("togglegroup"));
+    }
+
+    #[test]
+    fn serialize_legend() {
+        let legend = Legend::new()
+            .background_color("#123123")
+            .border_color("#321321")
+            .border_width(500)
+            .font(Font::new())
+            .orientation(Orientation::Vertical)
+            .trace_order(TraceOrder::Normal)
+            .trace_group_gap(10)
+            .item_sizing(ItemSizing::Trace)
+            .item_click(ItemClick::Toggle)
+            .item_double_click(ItemClick::False)
+            .x(1.0)
+            .x_anchor(Anchor::Auto)
+            .y(2.0)
+            .y_anchor(Anchor::Left)
+            .valign(VAlign::Middle)
+            .title("title")
+            .group_click(GroupClick::ToggleItem)
+            .item_width(50);
+
+        let expected = json!({
+            "bgcolor": "#123123",
+            "bordercolor": "#321321",
+            "borderwidth": 500,
+            "font": {},
+            "orientation": "v",
+            "traceorder": "normal",
+            "tracegroupgap": 10,
+            "itemsizing": "trace",
+            "itemclick": "toggle",
+            "itemdoubleclick": false,
+            "x": 1.0,
+            "xanchor": "auto",
+            "y": 2.0,
+            "yanchor": "left",
+            "valign": "middle",
+            "title": {"text": "title"},
+            "groupclick": "toggleitem",
+            "itemwidth": 50
+        });
+
+        assert_eq!(to_value(legend).unwrap(), expected)
+    }
+}
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index b0c7a618..0af53a20 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -3,25 +3,45 @@ pub mod update_menu;
 
 mod annotation;
 mod axis;
-// Re-export separated module types
+mod legend;
 use std::borrow::Cow;
 
 use plotly_derive::FieldSetter;
 use serde::{Serialize, Serializer};
 use update_menu::UpdateMenu;
 
-pub use self::annotation::{Annotation, ArrowSide, ClickToShow, HAlign, VAlign};
+// Re-export layout sub-module types
+pub use self::annotation::{Annotation, ArrowSide, ClickToShow};
 pub use self::axis::{
-    ArrayShow, Axis, AxisConstrain, AxisType, CategoryOrder, ConstrainDirection, TicksDirection,
-    TicksPosition,
+    ArrayShow, Axis, AxisConstrain, AxisType, CategoryOrder, ConstrainDirection, RangeMode,
+    RangeSelector, RangeSlider, RangeSliderYAxis, SelectorButton, SelectorStep, SliderRangeMode,
+    StepMode, TicksDirection, TicksPosition,
 };
+
+pub use self::legend::{Legend, TraceOrder};
+
 use crate::common::Domain;
 use crate::{
     color::Color,
-    common::{Anchor, Calendar, ColorBar, ColorScale, DashType, Font, Label, Orientation, Title},
+    common::{Calendar, ColorBar, ColorScale, DashType, Font, Label, Orientation, Title},
     private::NumOrString,
 };
 
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum VAlign {
+    Top,
+    Middle,
+    Bottom,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum HAlign {
+    Left,
+    Center,
+    Right,
+}
 #[derive(Serialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum BarMode {
@@ -61,91 +81,6 @@ pub enum WaterfallMode {
     Overlay,
 }
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum TraceOrder {
-    Reversed,
-    Grouped,
-    #[serde(rename = "reversed+grouped")]
-    ReversedGrouped,
-    Normal,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ItemSizing {
-    Trace,
-    Constant,
-}
-
-#[derive(Debug, Clone)]
-pub enum ItemClick {
-    Toggle,
-    ToggleOthers,
-    False,
-}
-
-impl Serialize for ItemClick {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match *self {
-            Self::Toggle => serializer.serialize_str("toggle"),
-            Self::ToggleOthers => serializer.serialize_str("toggleothers"),
-            Self::False => serializer.serialize_bool(false),
-        }
-    }
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum GroupClick {
-    ToggleItem,
-    ToggleGroup,
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct Legend {
-    #[serde(rename = "bgcolor")]
-    background_color: Option<Box<dyn Color>>,
-    #[serde(rename = "bordercolor")]
-    border_color: Option<Box<dyn Color>>,
-    #[serde(rename = "borderwidth")]
-    border_width: Option<usize>,
-    font: Option<Font>,
-    orientation: Option<Orientation>,
-    #[serde(rename = "traceorder")]
-    trace_order: Option<TraceOrder>,
-    #[serde(rename = "tracegroupgap")]
-    trace_group_gap: Option<usize>,
-    #[serde(rename = "itemsizing")]
-    item_sizing: Option<ItemSizing>,
-    #[serde(rename = "itemclick")]
-    item_click: Option<ItemClick>,
-    #[serde(rename = "itemdoubleclick")]
-    item_double_click: Option<ItemClick>,
-    x: Option<f64>,
-    #[serde(rename = "xanchor")]
-    x_anchor: Option<Anchor>,
-    y: Option<f64>,
-    #[serde(rename = "yanchor")]
-    y_anchor: Option<Anchor>,
-    valign: Option<VAlign>,
-    title: Option<Title>,
-    #[serde(rename = "groupclick")]
-    group_click: Option<GroupClick>,
-    #[serde(rename = "itemwidth")]
-    item_width: Option<usize>,
-}
-
-impl Legend {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
 pub struct Margin {
@@ -1493,81 +1428,18 @@ mod tests {
     }
 
     #[test]
-    #[rustfmt::skip]
-    fn serialize_trace_order() {
-        assert_eq!(to_value(TraceOrder::Reversed).unwrap(), json!("reversed"));
-        assert_eq!(to_value(TraceOrder::Grouped).unwrap(), json!("grouped"));
-        assert_eq!(to_value(TraceOrder::ReversedGrouped).unwrap(), json!("reversed+grouped"));
-        assert_eq!(to_value(TraceOrder::Normal).unwrap(), json!("normal"));
+    fn serialize_valign() {
+        assert_eq!(to_value(VAlign::Top).unwrap(), json!("top"));
+        assert_eq!(to_value(VAlign::Middle).unwrap(), json!("middle"));
+        assert_eq!(to_value(VAlign::Bottom).unwrap(), json!("bottom"));
     }
 
     #[test]
-    fn serialize_item_sizing() {
-        assert_eq!(to_value(ItemSizing::Trace).unwrap(), json!("trace"));
-        assert_eq!(to_value(ItemSizing::Constant).unwrap(), json!("constant"));
+    fn serialize_halign() {
+        assert_eq!(to_value(HAlign::Left).unwrap(), json!("left"));
+        assert_eq!(to_value(HAlign::Center).unwrap(), json!("center"));
+        assert_eq!(to_value(HAlign::Right).unwrap(), json!("right"));
     }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_item_click() {
-        assert_eq!(to_value(ItemClick::Toggle).unwrap(), json!("toggle"));
-        assert_eq!(to_value(ItemClick::ToggleOthers).unwrap(), json!("toggleothers"));
-        assert_eq!(to_value(ItemClick::False).unwrap(), json!(false));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_group_click() {
-        assert_eq!(to_value(GroupClick::ToggleItem).unwrap(), json!("toggleitem"));
-        assert_eq!(to_value(GroupClick::ToggleGroup).unwrap(), json!("togglegroup"));
-    }
-
-    #[test]
-    fn serialize_legend() {
-        let legend = Legend::new()
-            .background_color("#123123")
-            .border_color("#321321")
-            .border_width(500)
-            .font(Font::new())
-            .orientation(Orientation::Vertical)
-            .trace_order(TraceOrder::Normal)
-            .trace_group_gap(10)
-            .item_sizing(ItemSizing::Trace)
-            .item_click(ItemClick::Toggle)
-            .item_double_click(ItemClick::False)
-            .x(1.0)
-            .x_anchor(Anchor::Auto)
-            .y(2.0)
-            .y_anchor(Anchor::Left)
-            .valign(VAlign::Middle)
-            .title("title")
-            .group_click(GroupClick::ToggleItem)
-            .item_width(50);
-
-        let expected = json!({
-            "bgcolor": "#123123",
-            "bordercolor": "#321321",
-            "borderwidth": 500,
-            "font": {},
-            "orientation": "v",
-            "traceorder": "normal",
-            "tracegroupgap": 10,
-            "itemsizing": "trace",
-            "itemclick": "toggle",
-            "itemdoubleclick": false,
-            "x": 1.0,
-            "xanchor": "auto",
-            "y": 2.0,
-            "yanchor": "left",
-            "valign": "middle",
-            "title": {"text": "title"},
-            "groupclick": "toggleitem",
-            "itemwidth": 50
-        });
-
-        assert_eq!(to_value(legend).unwrap(), expected)
-    }
-
     #[test]
     fn serialize_margin() {
         let margin = Margin::new()

From 44325c632dbd410b8af364224857387e2385248d Mon Sep 17 00:00:00 2001
From: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
Date: Wed, 4 Jun 2025 09:46:12 +0200
Subject: [PATCH 4/8] extract grid types out of mod.rs

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
---
 plotly/src/layout/axis.rs |  93 ++++++++++++-
 plotly/src/layout/grid.rs | 166 +++++++++++++++++++++++
 plotly/src/layout/mod.rs  | 277 +-------------------------------------
 3 files changed, 264 insertions(+), 272 deletions(-)
 create mode 100644 plotly/src/layout/grid.rs

diff --git a/plotly/src/layout/axis.rs b/plotly/src/layout/axis.rs
index c1d7f24b..07da881e 100644
--- a/plotly/src/layout/axis.rs
+++ b/plotly/src/layout/axis.rs
@@ -3,7 +3,8 @@ use serde::Serialize;
 
 use crate::color::Color;
 use crate::common::{
-    Anchor, AxisSide, Calendar, DashType, ExponentFormat, Font, TickFormatStop, TickMode, Title,
+    Anchor, AxisSide, Calendar, ColorBar, ColorScale, DashType, ExponentFormat, Font,
+    TickFormatStop, TickMode, Title,
 };
 use crate::private::NumOrStringCollection;
 
@@ -65,6 +66,31 @@ pub enum AxisConstrain {
     Domain,
 }
 
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct ColorAxis {
+    cauto: Option<bool>,
+    cmin: Option<f64>,
+    cmax: Option<f64>,
+    cmid: Option<f64>,
+    #[serde(rename = "colorscale")]
+    color_scale: Option<ColorScale>,
+    #[serde(rename = "autocolorscale")]
+    auto_color_scale: Option<bool>,
+    #[serde(rename = "reversescale")]
+    reverse_scale: Option<bool>,
+    #[serde(rename = "showscale")]
+    show_scale: Option<bool>,
+    #[serde(rename = "colorbar")]
+    color_bar: Option<ColorBar>,
+}
+
+impl ColorAxis {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
 #[derive(Serialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum RangeMode {
@@ -419,6 +445,18 @@ mod tests {
     use serde_json::{json, to_value};
 
     use super::*;
+    use crate::common::ColorScalePalette;
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_axis_type() {
+        assert_eq!(to_value(AxisType::Default).unwrap(), json!("-"));
+        assert_eq!(to_value(AxisType::Linear).unwrap(), json!("linear"));
+        assert_eq!(to_value(AxisType::Log).unwrap(), json!("log"));
+        assert_eq!(to_value(AxisType::Date).unwrap(), json!("date"));
+        assert_eq!(to_value(AxisType::Category).unwrap(), json!("category"));
+        assert_eq!(to_value(AxisType::MultiCategory).unwrap(), json!("multicategory"));
+    }
 
     #[test]
     #[rustfmt::skip]
@@ -441,6 +479,59 @@ mod tests {
         assert_eq!(to_value(TicksPosition::Boundaries).unwrap(), json!("boundaries"));
     }
 
+    #[test]
+    fn serialize_axis_constrain() {
+        assert_eq!(to_value(AxisConstrain::Range).unwrap(), json!("range"));
+        assert_eq!(to_value(AxisConstrain::Domain).unwrap(), json!("domain"));
+    }
+
+    #[test]
+    fn serialize_array_show() {
+        assert_eq!(to_value(ArrayShow::All).unwrap(), json!("all"));
+        assert_eq!(to_value(ArrayShow::First).unwrap(), json!("first"));
+        assert_eq!(to_value(ArrayShow::Last).unwrap(), json!("last"));
+        assert_eq!(to_value(ArrayShow::None).unwrap(), json!("none"));
+    }
+
+    #[test]
+    fn serialize_color_axis() {
+        let color_axis = ColorAxis::new()
+            .auto_color_scale(false)
+            .cauto(true)
+            .cmax(1.0)
+            .cmid(0.5)
+            .cmin(0.0)
+            .color_bar(ColorBar::new())
+            .color_scale(ColorScale::Palette(ColorScalePalette::Greens))
+            .reverse_scale(false)
+            .show_scale(true);
+
+        let expected = json!({
+            "autocolorscale": false,
+            "cauto": true,
+            "cmin": 0.0,
+            "cmid": 0.5,
+            "cmax": 1.0,
+            "colorbar": {},
+            "colorscale": "Greens",
+            "reversescale": false,
+            "showscale": true,
+        });
+
+        assert_eq!(to_value(color_axis).unwrap(), expected);
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_constrain_direction() {
+        assert_eq!(to_value(ConstrainDirection::Left).unwrap(), json!("left"));
+        assert_eq!(to_value(ConstrainDirection::Center).unwrap(), json!("center"));
+        assert_eq!(to_value(ConstrainDirection::Right).unwrap(), json!("right"));
+        assert_eq!(to_value(ConstrainDirection::Top).unwrap(), json!("top"));
+        assert_eq!(to_value(ConstrainDirection::Middle).unwrap(), json!("middle"));
+        assert_eq!(to_value(ConstrainDirection::Bottom).unwrap(), json!("bottom"));
+    }
+
     #[test]
     #[rustfmt::skip]
     fn serialize_category_order() {
diff --git a/plotly/src/layout/grid.rs b/plotly/src/layout/grid.rs
new file mode 100644
index 00000000..c67e9007
--- /dev/null
+++ b/plotly/src/layout/grid.rs
@@ -0,0 +1,166 @@
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+#[derive(Serialize, Debug, Clone)]
+pub enum RowOrder {
+    #[serde(rename = "top to bottom")]
+    TopToBottom,
+    #[serde(rename = "bottom to top")]
+    BottomToTop,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum GridPattern {
+    Independent,
+    Coupled,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum GridXSide {
+    Bottom,
+    #[serde(rename = "bottom plot")]
+    BottomPlot,
+    #[serde(rename = "top plot")]
+    TopPlot,
+    Top,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum GridYSide {
+    Left,
+    #[serde(rename = "left plot")]
+    LeftPlot,
+    #[serde(rename = "right plot")]
+    RightPlot,
+    Right,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct GridDomain {
+    x: Option<Vec<f64>>,
+    y: Option<Vec<f64>>,
+}
+
+impl GridDomain {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct LayoutGrid {
+    rows: Option<usize>,
+    #[serde(rename = "roworder")]
+    row_order: Option<RowOrder>,
+    columns: Option<usize>,
+    #[serde(rename = "subplots")]
+    sub_plots: Option<Vec<String>>,
+    #[serde(rename = "xaxes")]
+    x_axes: Option<Vec<String>>,
+    #[serde(rename = "yaxes")]
+    y_axes: Option<Vec<String>>,
+    pattern: Option<GridPattern>,
+    #[serde(rename = "xgap")]
+    x_gap: Option<f64>,
+    #[serde(rename = "ygap")]
+    y_gap: Option<f64>,
+    domain: Option<GridDomain>,
+    #[serde(rename = "xside")]
+    x_side: Option<GridXSide>,
+    #[serde(rename = "yside")]
+    y_side: Option<GridYSide>,
+}
+
+impl LayoutGrid {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_row_order() {
+        assert_eq!(to_value(RowOrder::TopToBottom).unwrap(), json!("top to bottom"));
+        assert_eq!(to_value(RowOrder::BottomToTop).unwrap(), json!("bottom to top"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_grid_pattern() {
+        assert_eq!(to_value(GridPattern::Independent).unwrap(), json!("independent"));
+        assert_eq!(to_value(GridPattern::Coupled).unwrap(), json!("coupled"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_grid_x_side() {
+        assert_eq!(to_value(GridXSide::Bottom).unwrap(), json!("bottom"));
+        assert_eq!(to_value(GridXSide::BottomPlot).unwrap(), json!("bottom plot"));
+        assert_eq!(to_value(GridXSide::Top).unwrap(), json!("top"));
+        assert_eq!(to_value(GridXSide::TopPlot).unwrap(), json!("top plot"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_grid_y_side() {
+        assert_eq!(to_value(GridYSide::Left).unwrap(), json!("left"));
+        assert_eq!(to_value(GridYSide::LeftPlot).unwrap(), json!("left plot"));
+        assert_eq!(to_value(GridYSide::Right).unwrap(), json!("right"));
+        assert_eq!(to_value(GridYSide::RightPlot).unwrap(), json!("right plot"));
+    }
+
+    #[test]
+    fn serialize_grid_domain() {
+        let grid_domain = GridDomain::new().x(vec![0.0]).y(vec![1.0]);
+        let expected = json!({
+            "x": [0.0],
+            "y": [1.0]
+        });
+
+        assert_eq!(to_value(grid_domain).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_layout_grid() {
+        let layout_grid = LayoutGrid::new()
+            .rows(224)
+            .row_order(RowOrder::BottomToTop)
+            .columns(501)
+            .sub_plots(vec!["subplots".to_string()])
+            .x_axes(vec!["xaxes".to_string()])
+            .y_axes(vec!["yaxes".to_string()])
+            .pattern(GridPattern::Coupled)
+            .x_gap(2.2)
+            .y_gap(4.4)
+            .domain(GridDomain::new())
+            .x_side(GridXSide::Top)
+            .y_side(GridYSide::Right);
+
+        let expected = json!({
+            "rows": 224,
+            "roworder": "bottom to top",
+            "columns": 501,
+            "subplots": ["subplots"],
+            "xaxes": ["xaxes"],
+            "yaxes": ["yaxes"],
+            "pattern": "coupled",
+            "xgap": 2.2,
+            "ygap": 4.4,
+            "domain": {},
+            "xside": "top",
+            "yside": "right",
+        });
+
+        assert_eq!(to_value(layout_grid).unwrap(), expected);
+    }
+}
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index 0af53a20..bcbe00a6 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -3,6 +3,7 @@ pub mod update_menu;
 
 mod annotation;
 mod axis;
+mod grid;
 mod legend;
 use std::borrow::Cow;
 
@@ -13,17 +14,16 @@ use update_menu::UpdateMenu;
 // Re-export layout sub-module types
 pub use self::annotation::{Annotation, ArrowSide, ClickToShow};
 pub use self::axis::{
-    ArrayShow, Axis, AxisConstrain, AxisType, CategoryOrder, ConstrainDirection, RangeMode,
-    RangeSelector, RangeSlider, RangeSliderYAxis, SelectorButton, SelectorStep, SliderRangeMode,
-    StepMode, TicksDirection, TicksPosition,
+    ArrayShow, Axis, AxisConstrain, AxisType, CategoryOrder, ColorAxis, ConstrainDirection,
+    RangeMode, RangeSelector, RangeSlider, RangeSliderYAxis, SelectorButton, SelectorStep,
+    SliderRangeMode, StepMode, TicksDirection, TicksPosition,
 };
-
+pub use self::grid::{GridDomain, GridPattern, GridXSide, GridYSide, LayoutGrid, RowOrder};
 pub use self::legend::{Legend, TraceOrder};
-
 use crate::common::Domain;
 use crate::{
     color::Color,
-    common::{Calendar, ColorBar, ColorScale, DashType, Font, Label, Orientation, Title},
+    common::{Calendar, ColorScale, DashType, Font, Label, Orientation, Title},
     private::NumOrString,
 };
 
@@ -118,112 +118,6 @@ impl LayoutColorScale {
     }
 }
 
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct ColorAxis {
-    cauto: Option<bool>,
-    cmin: Option<f64>,
-    cmax: Option<f64>,
-    cmid: Option<f64>,
-    #[serde(rename = "colorscale")]
-    color_scale: Option<ColorScale>,
-    #[serde(rename = "autocolorscale")]
-    auto_color_scale: Option<bool>,
-    #[serde(rename = "reversescale")]
-    reverse_scale: Option<bool>,
-    #[serde(rename = "showscale")]
-    show_scale: Option<bool>,
-    #[serde(rename = "colorbar")]
-    color_bar: Option<ColorBar>,
-}
-
-impl ColorAxis {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[derive(Serialize, Debug, Clone)]
-pub enum RowOrder {
-    #[serde(rename = "top to bottom")]
-    TopToBottom,
-    #[serde(rename = "bottom to top")]
-    BottomToTop,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum GridPattern {
-    Independent,
-    Coupled,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum GridXSide {
-    Bottom,
-    #[serde(rename = "bottom plot")]
-    BottomPlot,
-    #[serde(rename = "top plot")]
-    TopPlot,
-    Top,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum GridYSide {
-    Left,
-    #[serde(rename = "left plot")]
-    LeftPlot,
-    #[serde(rename = "right plot")]
-    RightPlot,
-    Right,
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct GridDomain {
-    x: Option<Vec<f64>>,
-    y: Option<Vec<f64>>,
-}
-
-impl GridDomain {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct LayoutGrid {
-    rows: Option<usize>,
-    #[serde(rename = "roworder")]
-    row_order: Option<RowOrder>,
-    columns: Option<usize>,
-    #[serde(rename = "subplots")]
-    sub_plots: Option<Vec<String>>,
-    #[serde(rename = "xaxes")]
-    x_axes: Option<Vec<String>>,
-    #[serde(rename = "yaxes")]
-    y_axes: Option<Vec<String>>,
-    pattern: Option<GridPattern>,
-    #[serde(rename = "xgap")]
-    x_gap: Option<f64>,
-    #[serde(rename = "ygap")]
-    y_gap: Option<f64>,
-    domain: Option<GridDomain>,
-    #[serde(rename = "xside")]
-    x_side: Option<GridXSide>,
-    #[serde(rename = "yside")]
-    y_side: Option<GridYSide>,
-}
-
-impl LayoutGrid {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
 #[derive(Debug, Clone)]
 pub enum UniformTextMode {
     False,
@@ -1341,13 +1235,6 @@ mod tests {
         assert_eq!(to_value(UniformTextMode::Show).unwrap(), json!("show"));
     }
 
-    #[test]
-    fn serialize_click_to_show() {
-        assert_eq!(to_value(ClickToShow::False).unwrap(), json!(false));
-        assert_eq!(to_value(ClickToShow::OnOff).unwrap(), json!("onoff"));
-        assert_eq!(to_value(ClickToShow::OnOut).unwrap(), json!("onout"));
-    }
-
     #[test]
     fn serialize_hover_mode() {
         assert_eq!(to_value(HoverMode::X).unwrap(), json!("x"));
@@ -1358,42 +1245,6 @@ mod tests {
         assert_eq!(to_value(HoverMode::YUnified).unwrap(), json!("y unified"));
     }
 
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_axis_type() {
-        assert_eq!(to_value(AxisType::Default).unwrap(), json!("-"));
-        assert_eq!(to_value(AxisType::Linear).unwrap(), json!("linear"));
-        assert_eq!(to_value(AxisType::Log).unwrap(), json!("log"));
-        assert_eq!(to_value(AxisType::Date).unwrap(), json!("date"));
-        assert_eq!(to_value(AxisType::Category).unwrap(), json!("category"));
-        assert_eq!(to_value(AxisType::MultiCategory).unwrap(), json!("multicategory"));
-    }
-
-    #[test]
-    fn serialize_axis_constrain() {
-        assert_eq!(to_value(AxisConstrain::Range).unwrap(), json!("range"));
-        assert_eq!(to_value(AxisConstrain::Domain).unwrap(), json!("domain"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_constrain_direction() {
-        assert_eq!(to_value(ConstrainDirection::Left).unwrap(), json!("left"));
-        assert_eq!(to_value(ConstrainDirection::Center).unwrap(), json!("center"));
-        assert_eq!(to_value(ConstrainDirection::Right).unwrap(), json!("right"));
-        assert_eq!(to_value(ConstrainDirection::Top).unwrap(), json!("top"));
-        assert_eq!(to_value(ConstrainDirection::Middle).unwrap(), json!("middle"));
-        assert_eq!(to_value(ConstrainDirection::Bottom).unwrap(), json!("bottom"));
-    }
-
-    #[test]
-    fn serialize_array_show() {
-        assert_eq!(to_value(ArrayShow::All).unwrap(), json!("all"));
-        assert_eq!(to_value(ArrayShow::First).unwrap(), json!("first"));
-        assert_eq!(to_value(ArrayShow::Last).unwrap(), json!("last"));
-        assert_eq!(to_value(ArrayShow::None).unwrap(), json!("none"));
-    }
-
     #[test]
     fn serialize_bar_mode() {
         assert_eq!(to_value(BarMode::Stack).unwrap(), json!("stack"));
@@ -1476,122 +1327,6 @@ mod tests {
         assert_eq!(to_value(layout_color_scale).unwrap(), expected);
     }
 
-    #[test]
-    fn serialize_color_axis() {
-        let color_axis = ColorAxis::new()
-            .auto_color_scale(false)
-            .cauto(true)
-            .cmax(1.0)
-            .cmid(0.5)
-            .cmin(0.0)
-            .color_bar(ColorBar::new())
-            .color_scale(ColorScale::Palette(ColorScalePalette::Greens))
-            .reverse_scale(false)
-            .show_scale(true);
-
-        let expected = json!({
-            "autocolorscale": false,
-            "cauto": true,
-            "cmin": 0.0,
-            "cmid": 0.5,
-            "cmax": 1.0,
-            "colorbar": {},
-            "colorscale": "Greens",
-            "reversescale": false,
-            "showscale": true,
-        });
-
-        assert_eq!(to_value(color_axis).unwrap(), expected);
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_row_order() {
-        assert_eq!(to_value(RowOrder::TopToBottom).unwrap(), json!("top to bottom"));
-        assert_eq!(to_value(RowOrder::BottomToTop).unwrap(), json!("bottom to top"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_grid_pattern() {
-        assert_eq!(to_value(GridPattern::Independent).unwrap(), json!("independent"));
-        assert_eq!(to_value(GridPattern::Coupled).unwrap(), json!("coupled"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_grid_x_side() {
-        assert_eq!(to_value(GridXSide::Bottom).unwrap(), json!("bottom"));
-        assert_eq!(to_value(GridXSide::BottomPlot).unwrap(), json!("bottom plot"));
-        assert_eq!(to_value(GridXSide::Top).unwrap(), json!("top"));
-        assert_eq!(to_value(GridXSide::TopPlot).unwrap(), json!("top plot"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_grid_y_side() {
-        assert_eq!(to_value(GridYSide::Left).unwrap(), json!("left"));
-        assert_eq!(to_value(GridYSide::LeftPlot).unwrap(), json!("left plot"));
-        assert_eq!(to_value(GridYSide::Right).unwrap(), json!("right"));
-        assert_eq!(to_value(GridYSide::RightPlot).unwrap(), json!("right plot"));
-    }
-
-    #[test]
-    fn serialize_grid_domain() {
-        let grid_domain = GridDomain::new().x(vec![0.0]).y(vec![1.0]);
-        let expected = json!({
-            "x": [0.0],
-            "y": [1.0]
-        });
-
-        assert_eq!(to_value(grid_domain).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_layout_grid() {
-        let layout_grid = LayoutGrid::new()
-            .rows(224)
-            .row_order(RowOrder::BottomToTop)
-            .columns(501)
-            .sub_plots(vec!["subplots".to_string()])
-            .x_axes(vec!["xaxes".to_string()])
-            .y_axes(vec!["yaxes".to_string()])
-            .pattern(GridPattern::Coupled)
-            .x_gap(2.2)
-            .y_gap(4.4)
-            .domain(GridDomain::new())
-            .x_side(GridXSide::Top)
-            .y_side(GridYSide::Right);
-
-        let expected = json!({
-            "rows": 224,
-            "roworder": "bottom to top",
-            "columns": 501,
-            "subplots": ["subplots"],
-            "xaxes": ["xaxes"],
-            "yaxes": ["yaxes"],
-            "pattern": "coupled",
-            "xgap": 2.2,
-            "ygap": 4.4,
-            "domain": {},
-            "xside": "top",
-            "yside": "right",
-        });
-
-        assert_eq!(to_value(layout_grid).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_uniform_text() {
-        let uniform_text = UniformText::new().mode(UniformTextMode::Hide).min_size(5);
-        let expected = json!({
-            "mode": "hide",
-            "minsize": 5
-        });
-
-        assert_eq!(to_value(uniform_text).unwrap(), expected);
-    }
-
     #[test]
     fn serialize_mode_bar() {
         let mode_bar = ModeBar::new()

From 851fb0e1238387524c0dc193facfea5587c2c5ac Mon Sep 17 00:00:00 2001
From: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
Date: Wed, 4 Jun 2025 09:57:35 +0200
Subject: [PATCH 5/8] separate grid types

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
---
 plotly/src/layout/mod.rs   | 413 ++-----------------------------------
 plotly/src/layout/shape.rs | 401 +++++++++++++++++++++++++++++++++++
 2 files changed, 416 insertions(+), 398 deletions(-)
 create mode 100644 plotly/src/layout/shape.rs

diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index bcbe00a6..69a0846e 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -1,3 +1,14 @@
+use serde::{Serialize, Serializer};
+use std::borrow::Cow;
+use update_menu::UpdateMenu;
+
+use crate::common::Domain;
+use crate::{
+    color::Color,
+    common::{Calendar, ColorScale, Font, Label, Orientation, Title},
+};
+use plotly_derive::FieldSetter;
+
 pub mod themes;
 pub mod update_menu;
 
@@ -5,11 +16,7 @@ mod annotation;
 mod axis;
 mod grid;
 mod legend;
-use std::borrow::Cow;
-
-use plotly_derive::FieldSetter;
-use serde::{Serialize, Serializer};
-use update_menu::UpdateMenu;
+mod shape;
 
 // Re-export layout sub-module types
 pub use self::annotation::{Annotation, ArrowSide, ClickToShow};
@@ -20,11 +27,9 @@ pub use self::axis::{
 };
 pub use self::grid::{GridDomain, GridPattern, GridXSide, GridYSide, LayoutGrid, RowOrder};
 pub use self::legend::{Legend, TraceOrder};
-use crate::common::Domain;
-use crate::{
-    color::Color,
-    common::{Calendar, ColorScale, DashType, Font, Label, Orientation, Title},
-    private::NumOrString,
+pub use self::shape::{
+    ActiveShape, DrawDirection, FillRule, NewShape, Shape, ShapeLayer, ShapeLine, ShapeSizeMode,
+    ShapeType,
 };
 
 #[derive(Serialize, Debug, Clone)]
@@ -195,258 +200,6 @@ impl ModeBar {
     }
 }
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ShapeType {
-    Circle,
-    Rect,
-    Path,
-    Line,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ShapeLayer {
-    Below,
-    Above,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ShapeSizeMode {
-    Scaled,
-    Pixel,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum FillRule {
-    EvenOdd,
-    NonZero,
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct ShapeLine {
-    /// Sets the line color.
-    color: Option<Box<dyn Color>>,
-    /// Sets the line width (in px).
-    width: Option<f64>,
-    /// Sets the dash style of lines. Set to a dash type string ("solid", "dot",
-    /// "dash", "longdash", "dashdot", or "longdashdot") or a dash length
-    /// list in px (eg "5px,10px,2px,2px").
-    dash: Option<DashType>,
-}
-
-impl ShapeLine {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct Shape {
-    /// Determines whether or not this shape is visible.
-    visible: Option<bool>,
-    #[field_setter(skip)]
-    r#type: Option<ShapeType>,
-    /// Specifies whether shapes are drawn below or above traces.
-    layer: Option<ShapeLayer>,
-    /// Sets the shape's x coordinate axis. If set to an x axis id (e.g. "x" or
-    /// "x2"), the `x` position refers to an x coordinate. If set to
-    /// "paper", the `x` position refers to the distance from the left side
-    /// of the plotting area in normalized coordinates where "0" ("1")
-    /// corresponds to the left (right) side. If the axis `type` is "log", then
-    /// you must take the log of your desired range. If the axis `type` is
-    /// "date", then you must convert the date to unix time in milliseconds.
-    #[serde(rename = "xref")]
-    x_ref: Option<String>,
-    /// Sets the shapes's sizing mode along the x axis. If set to "scaled",
-    /// `x0`, `x1` and x coordinates within `path` refer to data values on
-    /// the x axis or a fraction of the plot area's width (`xref` set to
-    /// "paper"). If set to "pixel", `xanchor` specifies the x position
-    /// in terms of data or plot fraction but `x0`, `x1` and x coordinates
-    /// within `path` are pixels relative to `xanchor`. This way, the shape
-    /// can have a fixed width while maintaining a position relative to data
-    /// or plot fraction.
-    #[serde(rename = "xsizemode")]
-    x_size_mode: Option<ShapeSizeMode>,
-    /// Only relevant in conjunction with `xsizemode` set to "pixel". Specifies
-    /// the anchor point on the x axis to which `x0`, `x1` and x coordinates
-    /// within `path` are relative to. E.g. useful to attach a pixel sized
-    /// shape to a certain data value. No effect when `xsizemode` not set to
-    /// "pixel".
-    #[serde(rename = "xanchor")]
-    x_anchor: Option<NumOrString>,
-    /// Sets the shape's starting x position. See `type` and `xsizemode` for
-    /// more info.
-    x0: Option<NumOrString>,
-    /// Sets the shape's end x position. See `type` and `xsizemode` for more
-    /// info.
-    x1: Option<NumOrString>,
-    /// Sets the annotation's y coordinate axis. If set to an y axis id (e.g.
-    /// "y" or "y2"), the `y` position refers to an y coordinate If set to
-    /// "paper", the `y` position refers to the distance from the bottom of
-    /// the plotting area in normalized coordinates where "0" ("1")
-    /// corresponds to the bottom (top).
-    #[serde(rename = "yref")]
-    y_ref: Option<String>,
-    /// Sets the shapes's sizing mode along the y axis. If set to "scaled",
-    /// `y0`, `y1` and y coordinates within `path` refer to data values on
-    /// the y axis or a fraction of the plot area's height (`yref` set to
-    /// "paper"). If set to "pixel", `yanchor` specifies the y position
-    /// in terms of data or plot fraction but `y0`, `y1` and y coordinates
-    /// within `path` are pixels relative to `yanchor`. This way, the shape
-    /// can have a fixed height while maintaining a position relative to
-    /// data or plot fraction.
-    #[serde(rename = "ysizemode")]
-    y_size_mode: Option<ShapeSizeMode>,
-    /// Only relevant in conjunction with `ysizemode` set to "pixel". Specifies
-    /// the anchor point on the y axis to which `y0`, `y1` and y coordinates
-    /// within `path` are relative to. E.g. useful to attach a pixel sized
-    /// shape to a certain data value. No effect when `ysizemode` not set to
-    /// "pixel".
-    #[serde(rename = "yanchor")]
-    y_anchor: Option<NumOrString>,
-    /// Sets the shape's starting y position. See `type` and `ysizemode` for
-    /// more info.
-    y0: Option<NumOrString>,
-    /// Sets the shape's end y position. See `type` and `ysizemode` for more
-    /// info.
-    y1: Option<NumOrString>,
-    /// For `type` "path" - a valid SVG path with the pixel values replaced by
-    /// data values in `xsizemode`/`ysizemode` being "scaled" and taken
-    /// unmodified as pixels relative to `xanchor` and `yanchor` in case of
-    /// "pixel" size mode. There are a few restrictions / quirks
-    /// only absolute instructions, not relative. So the allowed segments
-    /// are: M, L, H, V, Q, C, T, S, and Z arcs (A) are not allowed because
-    /// radius rx and ry are relative. In the future we could consider
-    /// supporting relative commands, but we would have to decide on how to
-    /// handle date and log axes. Note that even as is, Q and C Bezier paths
-    /// that are smooth on linear axes may not be smooth on log, and vice versa.
-    /// no chained "polybezier" commands - specify the segment type for each
-    /// one. On category axes, values are numbers scaled to the serial
-    /// numbers of categories because using the categories themselves
-    /// there would be no way to describe fractional positions On data axes:
-    /// because space and T are both normal components of path strings, we
-    /// can't use either to separate date from time parts. Therefore we'll
-    /// use underscore for this purpose: 2015-02-21_13:45:56.789
-    path: Option<String>,
-    /// Sets the opacity of the shape. Number between or equal to 0 and 1.
-    opacity: Option<f64>,
-    /// Sets the shape line properties (`color`, `width`, `dash`).
-    line: Option<ShapeLine>,
-    /// Sets the color filling the shape's interior. Only applies to closed
-    /// shapes.
-    #[serde(rename = "fillcolor")]
-    fill_color: Option<Box<dyn Color>>,
-    /// Determines which regions of complex paths constitute the interior. For
-    /// more info please visit <https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/fill-rule>
-    #[serde(rename = "fillrule")]
-    fill_rule: Option<FillRule>,
-    /// Determines whether the shape could be activated for edit or not. Has no
-    /// effect when the older editable shapes mode is enabled via
-    /// `config.editable` or `config.edits.shapePosition`.
-    editable: Option<bool>,
-    /// When used in a template, named items are created in the output figure in
-    /// addition to any items the figure already has in this array. You can
-    /// modify these items in the output figure by making your own item with
-    /// `templateitemname` matching this `name` alongside your modifications
-    /// (including `visible: false` or `enabled: false` to hide it). Has no
-    /// effect outside of a template.
-    name: Option<String>,
-    /// Used to refer to a named item in this array in the template. Named items
-    /// from the template will be created even without a matching item in
-    /// the input figure, but you can modify one by making an item with
-    /// `templateitemname` matching its `name`, alongside your modifications
-    /// (including `visible: false` or `enabled: false` to hide it). If there is
-    /// no template or no matching item, this item will be hidden unless you
-    /// explicitly show it with `visible: true`.
-    #[serde(rename = "templateitemname")]
-    template_item_name: Option<String>,
-}
-
-impl Shape {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    /// Specifies the shape type to be drawn. If "line", a line is drawn from
-    /// (`x0`,`y0`) to (`x1`,`y1`) with respect to the axes' sizing mode. If
-    /// "circle", a circle is drawn from ((`x0`+`x1`)/2, (`y0`+`y1`)/2))
-    /// with radius (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 -`y0`)|)
-    /// with respect to the axes' sizing mode. If "rect", a rectangle is drawn
-    /// linking (`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), (`x0`,`y1`),
-    /// (`x0`,`y0`) with respect to the axes' sizing mode. If "path", draw a
-    /// custom SVG path using `path`. with respect to the axes' sizing mode.
-    pub fn shape_type(mut self, shape_type: ShapeType) -> Self {
-        self.r#type = Some(shape_type);
-        self
-    }
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum DrawDirection {
-    Ortho,
-    Horizontal,
-    Vertical,
-    Diagonal,
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct NewShape {
-    /// Sets the shape line properties (`color`, `width`, `dash`).
-    line: Option<ShapeLine>,
-    /// Sets the color filling new shapes' interior. Please note that if using a
-    /// fillcolor with alpha greater than half, drag inside the active shape
-    /// starts moving the shape underneath, otherwise a new shape could be
-    /// started over.
-    #[serde(rename = "fillcolor")]
-    fill_color: Option<Box<dyn Color>>,
-    /// Determines the path's interior. For more info please
-    /// visit <https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/fill-rule>
-    #[serde(rename = "fillrule")]
-    fill_rule: Option<FillRule>,
-    /// Sets the opacity of new shapes. Number between or equal to 0 and 1.
-    opacity: Option<f64>,
-    /// Specifies whether new shapes are drawn below or above traces.
-    layer: Option<ShapeLayer>,
-    /// When `dragmode` is set to "drawrect", "drawline" or "drawcircle" this
-    /// limits the drag to be horizontal, vertical or diagonal. Using
-    /// "diagonal" there is no limit e.g. in drawing lines in any direction.
-    /// "ortho" limits the draw to be either horizontal or vertical.
-    /// "horizontal" allows horizontal extend. "vertical" allows vertical
-    /// extend.
-    #[serde(rename = "drawdirection")]
-    draw_direction: Option<DrawDirection>,
-}
-
-impl NewShape {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct ActiveShape {
-    /// Sets the color filling the active shape' interior.
-    #[serde(rename = "fillcolor")]
-    fill_color: Option<Box<dyn Color>>,
-    /// Sets the opacity of the active shape. Number between or equal to 0 and
-    /// 1.
-    opacity: Option<f64>,
-}
-
-impl ActiveShape {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
 #[derive(Serialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum ClickMode {
@@ -1344,142 +1097,6 @@ mod tests {
         assert_eq!(to_value(mode_bar).unwrap(), expected);
     }
 
-    #[test]
-    fn serialize_shape_type() {
-        assert_eq!(to_value(ShapeType::Circle).unwrap(), json!("circle"));
-        assert_eq!(to_value(ShapeType::Rect).unwrap(), json!("rect"));
-        assert_eq!(to_value(ShapeType::Path).unwrap(), json!("path"));
-        assert_eq!(to_value(ShapeType::Line).unwrap(), json!("line"));
-    }
-
-    #[test]
-    fn serialize_shape_layer() {
-        assert_eq!(to_value(ShapeLayer::Below).unwrap(), json!("below"));
-        assert_eq!(to_value(ShapeLayer::Above).unwrap(), json!("above"));
-    }
-
-    #[test]
-    fn serialize_shape_size_mode() {
-        assert_eq!(to_value(ShapeSizeMode::Scaled).unwrap(), json!("scaled"));
-        assert_eq!(to_value(ShapeSizeMode::Pixel).unwrap(), json!("pixel"));
-    }
-
-    #[test]
-    fn serialize_fill_rule() {
-        assert_eq!(to_value(FillRule::EvenOdd).unwrap(), json!("evenodd"));
-        assert_eq!(to_value(FillRule::NonZero).unwrap(), json!("nonzero"));
-    }
-
-    #[test]
-    fn serialize_shape_line() {
-        let shape_line = ShapeLine::new()
-            .color("#000FFF")
-            .width(100.)
-            .dash(DashType::LongDashDot);
-        let expected = json!({
-            "color": "#000FFF",
-            "width": 100.0,
-            "dash": "longdashdot",
-        });
-
-        assert_eq!(to_value(shape_line).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_shape() {
-        let shape = Shape::new()
-            .visible(false)
-            .shape_type(ShapeType::Circle)
-            .layer(ShapeLayer::Above)
-            .x_ref("xref")
-            .x_size_mode(ShapeSizeMode::Pixel)
-            .x_anchor(5)
-            .x0(7)
-            .x1(8)
-            .y_ref("paper")
-            .y0(1)
-            .y1(2)
-            .y_anchor("yanchor")
-            .y_size_mode(ShapeSizeMode::Scaled)
-            .path("path")
-            .opacity(0.2)
-            .line(ShapeLine::new())
-            .fill_color("#FEFEFE")
-            .fill_rule(FillRule::NonZero)
-            .editable(true)
-            .name("name")
-            .template_item_name("templateitemname");
-
-        let expected = json!({
-            "visible": false,
-            "type": "circle",
-            "layer": "above",
-            "xref": "xref",
-            "xsizemode": "pixel",
-            "xanchor": 5,
-            "x0": 7,
-            "x1": 8,
-            "yref": "paper",
-            "y0": 1,
-            "y1": 2,
-            "yanchor": "yanchor",
-            "ysizemode": "scaled",
-            "path": "path",
-            "opacity": 0.2,
-            "line": {},
-            "fillcolor": "#FEFEFE",
-            "fillrule": "nonzero",
-            "editable": true,
-            "name": "name",
-            "templateitemname": "templateitemname"
-        });
-
-        assert_eq!(to_value(shape).unwrap(), expected)
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_draw_direction() {
-        assert_eq!(to_value(DrawDirection::Ortho).unwrap(), json!("ortho"));
-        assert_eq!(to_value(DrawDirection::Horizontal).unwrap(), json!("horizontal"));
-        assert_eq!(to_value(DrawDirection::Vertical).unwrap(), json!("vertical"));
-        assert_eq!(to_value(DrawDirection::Diagonal).unwrap(), json!("diagonal"));
-    }
-
-    #[test]
-    fn serialize_new_shape() {
-        let new_shape = NewShape::new()
-            .line(ShapeLine::new())
-            .fill_color("#123ABC")
-            .fill_rule(FillRule::EvenOdd)
-            .opacity(0.02)
-            .layer(ShapeLayer::Below)
-            .draw_direction(DrawDirection::Ortho);
-
-        let expected = json!({
-            "line": {},
-            "fillcolor": "#123ABC",
-            "fillrule": "evenodd",
-            "opacity": 0.02,
-            "layer": "below",
-            "drawdirection": "ortho",
-        });
-
-        assert_eq!(to_value(new_shape).unwrap(), expected)
-    }
-
-    #[test]
-    fn serialize_active_shape() {
-        let active_shape = ActiveShape::new().fill_color("#123ABC").opacity(0.02);
-
-        let expected = json!({
-            "fillcolor": "#123ABC",
-            "opacity": 0.02,
-        });
-
-        assert_eq!(to_value(active_shape).unwrap(), expected);
-    }
-
     #[test]
     fn serialize_arrow_side() {
         assert_eq!(to_value(ArrowSide::End).unwrap(), json!("end"));
diff --git a/plotly/src/layout/shape.rs b/plotly/src/layout/shape.rs
new file mode 100644
index 00000000..1cf1e203
--- /dev/null
+++ b/plotly/src/layout/shape.rs
@@ -0,0 +1,401 @@
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::color::Color;
+use crate::common::DashType;
+use crate::private::NumOrString;
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ShapeType {
+    Circle,
+    Rect,
+    Path,
+    Line,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ShapeLayer {
+    Below,
+    Above,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ShapeSizeMode {
+    Scaled,
+    Pixel,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct ShapeLine {
+    /// Sets the line color.
+    color: Option<Box<dyn Color>>,
+    /// Sets the line width (in px).
+    width: Option<f64>,
+    /// Sets the dash style of lines. Set to a dash type string ("solid", "dot",
+    /// "dash", "longdash", "dashdot", or "longdashdot") or a dash length
+    /// list in px (eg "5px,10px,2px,2px").
+    dash: Option<DashType>,
+}
+
+impl ShapeLine {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum FillRule {
+    EvenOdd,
+    NonZero,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct Shape {
+    /// Determines whether or not this shape is visible.
+    visible: Option<bool>,
+    #[field_setter(skip)]
+    r#type: Option<ShapeType>,
+    /// Specifies whether shapes are drawn below or above traces.
+    layer: Option<ShapeLayer>,
+    /// Sets the shape's x coordinate axis. If set to an x axis id (e.g. "x" or
+    /// "x2"), the `x` position refers to an x coordinate. If set to
+    /// "paper", the `x` position refers to the distance from the left side
+    /// of the plotting area in normalized coordinates where "0" ("1")
+    /// corresponds to the left (right) side. If the axis `type` is "log", then
+    /// you must take the log of your desired range. If the axis `type` is
+    /// "date", then you must convert the date to unix time in milliseconds.
+    #[serde(rename = "xref")]
+    x_ref: Option<String>,
+    /// Sets the shapes's sizing mode along the x axis. If set to "scaled",
+    /// `x0`, `x1` and x coordinates within `path` refer to data values on
+    /// the x axis or a fraction of the plot area's width (`xref` set to
+    /// "paper"). If set to "pixel", `xanchor` specifies the x position
+    /// in terms of data or plot fraction but `x0`, `x1` and x coordinates
+    /// within `path` are pixels relative to `xanchor`. This way, the shape
+    /// can have a fixed width while maintaining a position relative to data
+    /// or plot fraction.
+    #[serde(rename = "xsizemode")]
+    x_size_mode: Option<ShapeSizeMode>,
+    /// Only relevant in conjunction with `xsizemode` set to "pixel". Specifies
+    /// the anchor point on the x axis to which `x0`, `x1` and x coordinates
+    /// within `path` are relative to. E.g. useful to attach a pixel sized
+    /// shape to a certain data value. No effect when `xsizemode` not set to
+    /// "pixel".
+    #[serde(rename = "xanchor")]
+    x_anchor: Option<NumOrString>,
+    /// Sets the shape's starting x position. See `type` and `xsizemode` for
+    /// more info.
+    x0: Option<NumOrString>,
+    /// Sets the shape's end x position. See `type` and `xsizemode` for more
+    /// info.
+    x1: Option<NumOrString>,
+    /// Sets the annotation's y coordinate axis. If set to an y axis id (e.g.
+    /// "y" or "y2"), the `y` position refers to an y coordinate If set to
+    /// "paper", the `y` position refers to the distance from the bottom of
+    /// the plotting area in normalized coordinates where "0" ("1")
+    /// corresponds to the bottom (top).
+    #[serde(rename = "yref")]
+    y_ref: Option<String>,
+    /// Sets the shapes's sizing mode along the y axis. If set to "scaled",
+    /// `y0`, `y1` and y coordinates within `path` refer to data values on
+    /// the y axis or a fraction of the plot area's height (`yref` set to
+    /// "paper"). If set to "pixel", `yanchor` specifies the y position
+    /// in terms of data or plot fraction but `y0`, `y1` and y coordinates
+    /// within `path` are pixels relative to `yanchor`. This way, the shape
+    /// can have a fixed height while maintaining a position relative to
+    /// data or plot fraction.
+    #[serde(rename = "ysizemode")]
+    y_size_mode: Option<ShapeSizeMode>,
+    /// Only relevant in conjunction with `ysizemode` set to "pixel". Specifies
+    /// the anchor point on the y axis to which `y0`, `y1` and y coordinates
+    /// within `path` are relative to. E.g. useful to attach a pixel sized
+    /// shape to a certain data value. No effect when `ysizemode` not set to
+    /// "pixel".
+    #[serde(rename = "yanchor")]
+    y_anchor: Option<NumOrString>,
+    /// Sets the shape's starting y position. See `type` and `ysizemode` for
+    /// more info.
+    y0: Option<NumOrString>,
+    /// Sets the shape's end y position. See `type` and `ysizemode` for more
+    /// info.
+    y1: Option<NumOrString>,
+    /// For `type` "path" - a valid SVG path with the pixel values replaced by
+    /// data values in `xsizemode`/`ysizemode` being "scaled" and taken
+    /// unmodified as pixels relative to `xanchor` and `yanchor` in case of
+    /// "pixel" size mode. There are a few restrictions / quirks
+    /// only absolute instructions, not relative. So the allowed segments
+    /// are: M, L, H, V, Q, C, T, S, and Z arcs (A) are not allowed because
+    /// radius rx and ry are relative. In the future we could consider
+    /// supporting relative commands, but we would have to decide on how to
+    /// handle date and log axes. Note that even as is, Q and C Bezier paths
+    /// that are smooth on linear axes may not be smooth on log, and vice versa.
+    /// no chained "polybezier" commands - specify the segment type for each
+    /// one. On category axes, values are numbers scaled to the serial
+    /// numbers of categories because using the categories themselves
+    /// there would be no way to describe fractional positions On data axes:
+    /// because space and T are both normal components of path strings, we
+    /// can't use either to separate date from time parts. Therefore we'll
+    /// use underscore for this purpose: 2015-02-21_13:45:56.789
+    path: Option<String>,
+    /// Sets the opacity of the shape. Number between or equal to 0 and 1.
+    opacity: Option<f64>,
+    /// Sets the shape line properties (`color`, `width`, `dash`).
+    line: Option<ShapeLine>,
+    /// Sets the color filling the shape's interior. Only applies to closed
+    /// shapes.
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    /// Determines which regions of complex paths constitute the interior. For
+    /// more info please visit <https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/fill-rule>
+    #[serde(rename = "fillrule")]
+    fill_rule: Option<FillRule>,
+    /// Determines whether the shape could be activated for edit or not. Has no
+    /// effect when the older editable shapes mode is enabled via
+    /// `config.editable` or `config.edits.shapePosition`.
+    editable: Option<bool>,
+    /// When used in a template, named items are created in the output figure in
+    /// addition to any items the figure already has in this array. You can
+    /// modify these items in the output figure by making your own item with
+    /// `templateitemname` matching this `name` alongside your modifications
+    /// (including `visible: false` or `enabled: false` to hide it). Has no
+    /// effect outside of a template.
+    name: Option<String>,
+    /// Used to refer to a named item in this array in the template. Named items
+    /// from the template will be created even without a matching item in
+    /// the input figure, but you can modify one by making an item with
+    /// `templateitemname` matching its `name`, alongside your modifications
+    /// (including `visible: false` or `enabled: false` to hide it). If there is
+    /// no template or no matching item, this item will be hidden unless you
+    /// explicitly show it with `visible: true`.
+    #[serde(rename = "templateitemname")]
+    template_item_name: Option<String>,
+}
+
+impl Shape {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Specifies the shape type to be drawn. If "line", a line is drawn from
+    /// (`x0`,`y0`) to (`x1`,`y1`) with respect to the axes' sizing mode. If
+    /// "circle", a circle is drawn from ((`x0`+`x1`)/2, (`y0`+`y1`)/2))
+    /// with radius (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 -`y0`)|)
+    /// with respect to the axes' sizing mode. If "rect", a rectangle is drawn
+    /// linking (`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), (`x0`,`y1`),
+    /// (`x0`,`y0`) with respect to the axes' sizing mode. If "path", draw a
+    /// custom SVG path using `path`. with respect to the axes' sizing mode.
+    pub fn shape_type(mut self, shape_type: ShapeType) -> Self {
+        self.r#type = Some(shape_type);
+        self
+    }
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum DrawDirection {
+    Ortho,
+    Horizontal,
+    Vertical,
+    Diagonal,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct NewShape {
+    /// Sets the shape line properties (`color`, `width`, `dash`).
+    line: Option<ShapeLine>,
+    /// Sets the color filling new shapes' interior. Please note that if using a
+    /// fillcolor with alpha greater than half, drag inside the active shape
+    /// starts moving the shape underneath, otherwise a new shape could be
+    /// started over.
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    /// Determines the path's interior. For more info please
+    /// visit <https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/fill-rule>
+    #[serde(rename = "fillrule")]
+    fill_rule: Option<FillRule>,
+    /// Sets the opacity of new shapes. Number between or equal to 0 and 1.
+    opacity: Option<f64>,
+    /// Specifies whether new shapes are drawn below or above traces.
+    layer: Option<ShapeLayer>,
+    /// When `dragmode` is set to "drawrect", "drawline" or "drawcircle" this
+    /// limits the drag to be horizontal, vertical or diagonal. Using
+    /// "diagonal" there is no limit e.g. in drawing lines in any direction.
+    /// "ortho" limits the draw to be either horizontal or vertical.
+    /// "horizontal" allows horizontal extend. "vertical" allows vertical
+    /// extend.
+    #[serde(rename = "drawdirection")]
+    draw_direction: Option<DrawDirection>,
+}
+
+impl NewShape {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+pub struct ActiveShape {
+    /// Sets the color filling the active shape' interior.
+    #[serde(rename = "fillcolor")]
+    fill_color: Option<Box<dyn Color>>,
+    /// Sets the opacity of the active shape. Number between or equal to 0 and
+    /// 1.
+    opacity: Option<f64>,
+}
+
+impl ActiveShape {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    fn serialize_shape_type() {
+        assert_eq!(to_value(ShapeType::Circle).unwrap(), json!("circle"));
+        assert_eq!(to_value(ShapeType::Rect).unwrap(), json!("rect"));
+        assert_eq!(to_value(ShapeType::Path).unwrap(), json!("path"));
+        assert_eq!(to_value(ShapeType::Line).unwrap(), json!("line"));
+    }
+
+    #[test]
+    fn serialize_shape_layer() {
+        assert_eq!(to_value(ShapeLayer::Below).unwrap(), json!("below"));
+        assert_eq!(to_value(ShapeLayer::Above).unwrap(), json!("above"));
+    }
+
+    #[test]
+    fn serialize_shape_size_mode() {
+        assert_eq!(to_value(ShapeSizeMode::Scaled).unwrap(), json!("scaled"));
+        assert_eq!(to_value(ShapeSizeMode::Pixel).unwrap(), json!("pixel"));
+    }
+
+    #[test]
+    fn serialize_fill_rule() {
+        assert_eq!(to_value(FillRule::EvenOdd).unwrap(), json!("evenodd"));
+        assert_eq!(to_value(FillRule::NonZero).unwrap(), json!("nonzero"));
+    }
+
+    #[test]
+    fn serialize_shape_line() {
+        let shape_line = ShapeLine::new()
+            .color("#000FFF")
+            .width(100.)
+            .dash(DashType::LongDashDot);
+        let expected = json!({
+            "color": "#000FFF",
+            "width": 100.0,
+            "dash": "longdashdot",
+        });
+
+        assert_eq!(to_value(shape_line).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_shape() {
+        let shape = Shape::new()
+            .visible(false)
+            .shape_type(ShapeType::Circle)
+            .layer(ShapeLayer::Above)
+            .x_ref("xref")
+            .x_size_mode(ShapeSizeMode::Pixel)
+            .x_anchor(5)
+            .x0(7)
+            .x1(8)
+            .y_ref("paper")
+            .y0(1)
+            .y1(2)
+            .y_anchor("yanchor")
+            .y_size_mode(ShapeSizeMode::Scaled)
+            .path("path")
+            .opacity(0.2)
+            .line(ShapeLine::new())
+            .fill_color("#FEFEFE")
+            .fill_rule(FillRule::NonZero)
+            .editable(true)
+            .name("name")
+            .template_item_name("templateitemname");
+
+        let expected = json!({
+            "visible": false,
+            "type": "circle",
+            "layer": "above",
+            "xref": "xref",
+            "xsizemode": "pixel",
+            "xanchor": 5,
+            "x0": 7,
+            "x1": 8,
+            "yref": "paper",
+            "y0": 1,
+            "y1": 2,
+            "yanchor": "yanchor",
+            "ysizemode": "scaled",
+            "path": "path",
+            "opacity": 0.2,
+            "line": {},
+            "fillcolor": "#FEFEFE",
+            "fillrule": "nonzero",
+            "editable": true,
+            "name": "name",
+            "templateitemname": "templateitemname"
+        });
+
+        assert_eq!(to_value(shape).unwrap(), expected)
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_draw_direction() {
+        assert_eq!(to_value(DrawDirection::Ortho).unwrap(), json!("ortho"));
+        assert_eq!(to_value(DrawDirection::Horizontal).unwrap(), json!("horizontal"));
+        assert_eq!(to_value(DrawDirection::Vertical).unwrap(), json!("vertical"));
+        assert_eq!(to_value(DrawDirection::Diagonal).unwrap(), json!("diagonal"));
+    }
+
+    #[test]
+    fn serialize_new_shape() {
+        let new_shape = NewShape::new()
+            .line(ShapeLine::new())
+            .fill_color("#123ABC")
+            .fill_rule(FillRule::EvenOdd)
+            .opacity(0.02)
+            .layer(ShapeLayer::Below)
+            .draw_direction(DrawDirection::Ortho);
+
+        let expected = json!({
+            "line": {},
+            "fillcolor": "#123ABC",
+            "fillrule": "evenodd",
+            "opacity": 0.02,
+            "layer": "below",
+            "drawdirection": "ortho",
+        });
+
+        assert_eq!(to_value(new_shape).unwrap(), expected)
+    }
+
+    #[test]
+    fn serialize_active_shape() {
+        let active_shape = ActiveShape::new().fill_color("#123ABC").opacity(0.02);
+
+        let expected = json!({
+            "fillcolor": "#123ABC",
+            "opacity": 0.02,
+        });
+
+        assert_eq!(to_value(active_shape).unwrap(), expected);
+    }
+}

From fc38e7b1ca5367f7b16b7d1bbff2c11144f62002 Mon Sep 17 00:00:00 2001
From: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
Date: Wed, 4 Jun 2025 10:24:52 +0200
Subject: [PATCH 6/8] separate remaining larger types

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
---
 plotly/src/layout/mapbox.rs |  96 +++++
 plotly/src/layout/mod.rs    | 739 +-----------------------------------
 plotly/src/layout/modes.rs  | 126 ++++++
 plotly/src/layout/scene.rs  | 538 ++++++++++++++++++++++++++
 4 files changed, 769 insertions(+), 730 deletions(-)
 create mode 100644 plotly/src/layout/mapbox.rs
 create mode 100644 plotly/src/layout/modes.rs
 create mode 100644 plotly/src/layout/scene.rs

diff --git a/plotly/src/layout/mapbox.rs b/plotly/src/layout/mapbox.rs
new file mode 100644
index 00000000..b53e3979
--- /dev/null
+++ b/plotly/src/layout/mapbox.rs
@@ -0,0 +1,96 @@
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::common::Domain;
+
+/// Defines the latitude and longitude at which a map will be centered.
+#[derive(Serialize, Clone, Debug)]
+pub struct Center {
+    lat: f64,
+    lon: f64,
+}
+
+impl Center {
+    /// Create a new instance of `Center`.
+    ///
+    /// `lat` is the number of degrees north, `lon` is the number of degrees
+    /// east.
+    pub fn new(lat: f64, lon: f64) -> Self {
+        Center { lat, lon }
+    }
+}
+
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "kebab-case")]
+pub enum MapboxStyle {
+    #[serde(rename = "carto-darkmatter")]
+    CartoDarkMatter,
+    CartoPositron,
+    OpenStreetMap,
+    StamenTerrain,
+    StamenToner,
+    StamenWatercolor,
+    WhiteBg,
+    Basic,
+    Streets,
+    Outdoors,
+    Light,
+    Dark,
+    Satellite,
+    SatelliteStreets,
+}
+
+#[derive(Serialize, Clone, Debug, FieldSetter)]
+pub struct Mapbox {
+    /// Sets the mapbox access token to be used for this mapbox map. Note that
+    /// `access_token`s are only required when `style` (e.g with values: basic,
+    /// streets, outdoors, light, dark, satellite, satellite-streets)
+    /// and/or a layout layer references the Mapbox server.
+    #[serde(rename = "accesstoken")]
+    access_token: Option<String>,
+    /// Sets the bearing angle of the map in degrees counter-clockwise from
+    /// North.
+    bearing: Option<f64>,
+    /// Sets the latitude and longitude of the center of the map.
+    center: Option<Center>,
+    /// Sets the domain within which the mapbox will be drawn.
+    domain: Option<Domain>,
+    /// Sets the pitch angle of the map in degrees, where `0` means
+    /// perpendicular to the surface of the map.
+    pitch: Option<f64>,
+    /// Sets the style of the map.
+    style: Option<MapboxStyle>,
+    /// Sets the zoom level of the map.
+    zoom: Option<u8>,
+}
+
+impl Mapbox {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::{json, to_value};
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_mapbox_style() {
+        assert_eq!(to_value(MapboxStyle::CartoDarkMatter).unwrap(), json!("carto-darkmatter"));
+        assert_eq!(to_value(MapboxStyle::CartoPositron).unwrap(), json!("carto-positron"));
+        assert_eq!(to_value(MapboxStyle::OpenStreetMap).unwrap(), json!("open-street-map"));
+        assert_eq!(to_value(MapboxStyle::StamenTerrain).unwrap(), json!("stamen-terrain"));
+        assert_eq!(to_value(MapboxStyle::StamenToner).unwrap(), json!("stamen-toner"));
+        assert_eq!(to_value(MapboxStyle::StamenWatercolor).unwrap(), json!("stamen-watercolor"));
+        assert_eq!(to_value(MapboxStyle::WhiteBg).unwrap(), json!("white-bg"));
+        assert_eq!(to_value(MapboxStyle::Basic).unwrap(), json!("basic"));
+        assert_eq!(to_value(MapboxStyle::Streets).unwrap(), json!("streets"));
+        assert_eq!(to_value(MapboxStyle::Outdoors).unwrap(), json!("outdoors"));
+        assert_eq!(to_value(MapboxStyle::Light).unwrap(), json!("light"));
+        assert_eq!(to_value(MapboxStyle::Dark).unwrap(), json!("dark"));
+        assert_eq!(to_value(MapboxStyle::Satellite).unwrap(), json!("satellite"));
+        assert_eq!(to_value(MapboxStyle::SatelliteStreets).unwrap(), json!("satellite-streets"));
+    }
+}
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index 69a0846e..d2093828 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -1,8 +1,7 @@
-use serde::{Serialize, Serializer};
+use serde::Serialize;
 use std::borrow::Cow;
 use update_menu::UpdateMenu;
 
-use crate::common::Domain;
 use crate::{
     color::Color,
     common::{Calendar, ColorScale, Font, Label, Orientation, Title},
@@ -16,6 +15,9 @@ mod annotation;
 mod axis;
 mod grid;
 mod legend;
+mod mapbox;
+mod modes;
+mod scene;
 mod shape;
 
 // Re-export layout sub-module types
@@ -27,6 +29,11 @@ pub use self::axis::{
 };
 pub use self::grid::{GridDomain, GridPattern, GridXSide, GridYSide, LayoutGrid, RowOrder};
 pub use self::legend::{Legend, TraceOrder};
+pub use self::mapbox::{Mapbox, MapboxStyle};
+pub use self::modes::{
+    BarMode, BarNorm, BoxMode, ClickMode, UniformTextMode, ViolinMode, WaterfallMode,
+};
+pub use self::scene::{DragMode, DragMode3D, HoverMode, LayoutScene, Projection, ProjectionType};
 pub use self::shape::{
     ActiveShape, DrawDirection, FillRule, NewShape, Shape, ShapeLayer, ShapeLine, ShapeSizeMode,
     ShapeType,
@@ -47,44 +54,6 @@ pub enum HAlign {
     Center,
     Right,
 }
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum BarMode {
-    Stack,
-    Group,
-    Overlay,
-    Relative,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum BarNorm {
-    #[serde(rename = "")]
-    Empty,
-    Fraction,
-    Percent,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum BoxMode {
-    Group,
-    Overlay,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ViolinMode {
-    Group,
-    Overlay,
-}
-
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum WaterfallMode {
-    Group,
-    Overlay,
-}
 
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
@@ -123,26 +92,6 @@ impl LayoutColorScale {
     }
 }
 
-#[derive(Debug, Clone)]
-pub enum UniformTextMode {
-    False,
-    Hide,
-    Show,
-}
-
-impl Serialize for UniformTextMode {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Self::False => serializer.serialize_bool(false),
-            Self::Hide => serializer.serialize_str("hide"),
-            Self::Show => serializer.serialize_str("show"),
-        }
-    }
-}
-
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
 pub struct UniformText {
@@ -157,32 +106,6 @@ impl UniformText {
     }
 }
 
-#[derive(Debug, Clone)]
-pub enum HoverMode {
-    X,
-    Y,
-    Closest,
-    False,
-    XUnified,
-    YUnified,
-}
-
-impl Serialize for HoverMode {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Self::X => serializer.serialize_str("x"),
-            Self::Y => serializer.serialize_str("y"),
-            Self::Closest => serializer.serialize_str("closest"),
-            Self::False => serializer.serialize_bool(false),
-            Self::XUnified => serializer.serialize_str("x unified"),
-            Self::YUnified => serializer.serialize_str("y unified"),
-        }
-    }
-}
-
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
 pub struct ModeBar {
@@ -200,79 +123,6 @@ impl ModeBar {
     }
 }
 
-#[derive(Serialize, Debug, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum ClickMode {
-    Event,
-    Select,
-    #[serde(rename = "event+select")]
-    EventAndSelect,
-    None,
-}
-
-#[derive(Debug, Clone)]
-pub enum DragMode {
-    Zoom,
-    Pan,
-    Select,
-    Lasso,
-    DrawClosedPath,
-    DrawOpenPath,
-    DrawLine,
-    DrawRect,
-    DrawCircle,
-    Orbit,
-    Turntable,
-    False,
-}
-
-impl Serialize for DragMode {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match *self {
-            Self::Zoom => serializer.serialize_str("zoom"),
-            Self::Pan => serializer.serialize_str("pan"),
-            Self::Select => serializer.serialize_str("select"),
-            Self::Lasso => serializer.serialize_str("lasso"),
-            Self::DrawClosedPath => serializer.serialize_str("drawclosedpath"),
-            Self::DrawOpenPath => serializer.serialize_str("drawopenpath"),
-            Self::DrawLine => serializer.serialize_str("drawline"),
-            Self::DrawRect => serializer.serialize_str("drawrect"),
-            Self::DrawCircle => serializer.serialize_str("drawcircle"),
-            Self::Orbit => serializer.serialize_str("orbit"),
-            Self::Turntable => serializer.serialize_str("turntable"),
-            Self::False => serializer.serialize_bool(false),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-/// Determines the mode of drag interactions.
-pub enum DragMode3D {
-    Zoom,
-    Pan,
-    Turntable,
-    Orbit,
-    False,
-}
-
-impl Serialize for DragMode3D {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match *self {
-            Self::Zoom => serializer.serialize_str("zoom"),
-            Self::Pan => serializer.serialize_str("pan"),
-            Self::Turntable => serializer.serialize_str("turntable"),
-            Self::Orbit => serializer.serialize_str("orbit"),
-            Self::False => serializer.serialize_bool(false),
-        }
-    }
-}
-
 #[derive(Serialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum SelectDirection {
@@ -285,303 +135,6 @@ pub enum SelectDirection {
     Any,
 }
 
-/// Defines the latitude and longitude at which a map will be centered.
-#[derive(Serialize, Clone, Debug)]
-pub struct Center {
-    lat: f64,
-    lon: f64,
-}
-
-impl Center {
-    /// Create a new instance of `Center`.
-    ///
-    /// `lat` is the number of degrees north, `lon` is the number of degrees
-    /// east.
-    pub fn new(lat: f64, lon: f64) -> Self {
-        Center { lat, lon }
-    }
-}
-
-#[derive(Serialize, Clone, Debug)]
-#[serde(rename_all = "kebab-case")]
-pub enum MapboxStyle {
-    #[serde(rename = "carto-darkmatter")]
-    CartoDarkMatter,
-    CartoPositron,
-    OpenStreetMap,
-    StamenTerrain,
-    StamenToner,
-    StamenWatercolor,
-    WhiteBg,
-    Basic,
-    Streets,
-    Outdoors,
-    Light,
-    Dark,
-    Satellite,
-    SatelliteStreets,
-}
-
-#[derive(Serialize, Clone, Debug, FieldSetter)]
-pub struct Mapbox {
-    /// Sets the mapbox access token to be used for this mapbox map. Note that
-    /// `access_token`s are only required when `style` (e.g with values: basic,
-    /// streets, outdoors, light, dark, satellite, satellite-streets)
-    /// and/or a layout layer references the Mapbox server.
-    #[serde(rename = "accesstoken")]
-    access_token: Option<String>,
-    /// Sets the bearing angle of the map in degrees counter-clockwise from
-    /// North.
-    bearing: Option<f64>,
-    /// Sets the latitude and longitude of the center of the map.
-    center: Option<Center>,
-    /// Sets the domain within which the mapbox will be drawn.
-    domain: Option<Domain>,
-    /// Sets the pitch angle of the map in degrees, where `0` means
-    /// perpendicular to the surface of the map.
-    pitch: Option<f64>,
-    /// Sets the style of the map.
-    style: Option<MapboxStyle>,
-    /// Sets the zoom level of the map.
-    zoom: Option<u8>,
-}
-
-impl Mapbox {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[derive(Serialize, Debug, Clone)]
-/// If "cube", this scene's axes are drawn as a cube, regardless of the axes'
-/// ranges. If "data", this scene's axes are drawn in proportion with the axes'
-/// ranges. If "manual", this scene's axes are drawn in proportion with the
-/// input of "aspectratio" (the default behavior if "aspectratio" is provided).
-/// If "auto", this scene's axes are drawn using the results of "data" except
-/// when one axis is more than four times the size of the two others, where in
-/// that case the results of "cube" are used.
-/// Default: "auto"
-#[derive(Default)]
-pub enum AspectMode {
-    #[serde(rename = "auto")]
-    #[default]
-    Auto,
-    #[serde(rename = "cube")]
-    Cube,
-    #[serde(rename = "data")]
-    Data,
-    #[serde(rename = "manual")]
-    Manual,
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-/// Sets the (x, y, z) components of the 'eye' camera vector. This vector
-/// determines the view point about the origin of this scene.
-/// Default: {x: 1.25, y: 1.25, z: 1.25}
-pub struct Eye {
-    x: Option<f64>,
-    y: Option<f64>,
-    z: Option<f64>,
-}
-
-impl Eye {
-    pub fn new() -> Self {
-        Eye {
-            x: Some(1.25),
-            y: Some(1.25),
-            z: Some(1.25),
-        }
-    }
-}
-
-impl From<(f64, f64, f64)> for Eye {
-    fn from((x, y, z): (f64, f64, f64)) -> Self {
-        Eye {
-            x: Some(x),
-            y: Some(y),
-            z: Some(z),
-        }
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-/// Sets the (x, y, z) components of the 'up' camera vector. This vector
-/// determines the up direction of this scene with respect to the page. The
-/// Default: {x: 0, y: 0, z: 1} which means that the z axis points up.
-pub struct Up {
-    x: Option<f64>,
-    y: Option<f64>,
-    z: Option<f64>,
-}
-
-impl Up {
-    pub fn new() -> Self {
-        Up {
-            x: Some(0.0),
-            y: Some(0.0),
-            z: Some(1.0),
-        }
-    }
-}
-
-impl From<(f64, f64, f64)> for Up {
-    fn from((x, y, z): (f64, f64, f64)) -> Self {
-        Up {
-            x: Some(x),
-            y: Some(y),
-            z: Some(z),
-        }
-    }
-}
-
-#[derive(Default, Serialize, Debug, Clone)]
-/// Sets the projection type. The projection type could be either "perspective"
-/// or "orthographic".
-/// Default: "perspective"
-pub enum ProjectionType {
-    #[default]
-    #[serde(rename = "perspective")]
-    Perspective,
-    #[serde(rename = "orthographic")]
-    Orthographic,
-}
-
-impl From<ProjectionType> for Projection {
-    fn from(projection_type: ProjectionType) -> Self {
-        Projection {
-            projection_type: Some(projection_type),
-        }
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-/// Container for Projection options.
-pub struct Projection {
-    #[serde(rename = "type")]
-    projection_type: Option<ProjectionType>,
-}
-
-impl Projection {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-/// Sets the (x, y, z) components of the 'center' camera vector. This vector
-/// determines the translation (x, y, z) space about the center of this scene.
-/// Default: {x: 0, y: 0, z: 0} which means that the center of the scene is at
-/// the origin.
-pub struct CameraCenter {
-    x: Option<f64>,
-    y: Option<f64>,
-    z: Option<f64>,
-}
-
-impl CameraCenter {
-    pub fn new() -> Self {
-        CameraCenter {
-            x: Some(0.0),
-            y: Some(0.0),
-            z: Some(0.0),
-        }
-    }
-}
-
-impl From<(f64, f64, f64)> for CameraCenter {
-    fn from((x, y, z): (f64, f64, f64)) -> Self {
-        CameraCenter {
-            x: Some(x),
-            y: Some(y),
-            z: Some(z),
-        }
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-/// Container for CameraCenter, Eye, Up, and Projection objects. The camera of a
-/// 3D scene.
-pub struct Camera {
-    center: Option<CameraCenter>,
-    eye: Option<Eye>,
-    up: Option<Up>,
-    projection: Option<Projection>,
-}
-
-impl Camera {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-/// Sets this scene's axis aspectratio.
-/// x, y, z must be positive.
-/// Default: {x: 1, y: 1, z: 1}
-pub struct AspectRatio {
-    x: Option<f64>,
-    y: Option<f64>,
-    z: Option<f64>,
-}
-
-impl AspectRatio {
-    pub fn new() -> Self {
-        AspectRatio {
-            x: Some(1.0),
-            y: Some(1.0),
-            z: Some(1.0),
-        }
-    }
-}
-
-impl From<(f64, f64, f64)> for AspectRatio {
-    fn from((x, y, z): (f64, f64, f64)) -> Self {
-        AspectRatio {
-            x: Some(x),
-            y: Some(y),
-            z: Some(z),
-        }
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-/// 3D scene layout
-pub struct LayoutScene {
-    #[serde(rename = "bgcolor")]
-    background_color: Option<Box<dyn Color>>,
-    camera: Option<Camera>,
-    #[serde(rename = "aspectmode")]
-    aspect_mode: Option<AspectMode>,
-    #[serde(rename = "aspectratio")]
-    aspect_ratio: Option<AspectRatio>,
-    #[serde(rename = "xaxis")]
-    x_axis: Option<Axis>,
-    #[serde(rename = "yaxis")]
-    y_axis: Option<Axis>,
-    #[serde(rename = "zaxis")]
-    z_axis: Option<Axis>,
-    #[serde(rename = "dragmode")]
-    drag_mode: Option<DragMode3D>,
-    #[serde(rename = "hovermode")]
-    hover_mode: Option<HoverMode>,
-    annotations: Option<Vec<Annotation>>,
-    // domain: Domain,
-    // uirevision: Uirevision,
-}
-
-impl LayoutScene {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
 pub struct Template {
@@ -981,56 +534,6 @@ mod tests {
     use super::*;
     use crate::common::ColorScalePalette;
 
-    #[test]
-    fn serialize_uniform_text_mode() {
-        assert_eq!(to_value(UniformTextMode::False).unwrap(), json!(false));
-        assert_eq!(to_value(UniformTextMode::Hide).unwrap(), json!("hide"));
-        assert_eq!(to_value(UniformTextMode::Show).unwrap(), json!("show"));
-    }
-
-    #[test]
-    fn serialize_hover_mode() {
-        assert_eq!(to_value(HoverMode::X).unwrap(), json!("x"));
-        assert_eq!(to_value(HoverMode::Y).unwrap(), json!("y"));
-        assert_eq!(to_value(HoverMode::Closest).unwrap(), json!("closest"));
-        assert_eq!(to_value(HoverMode::False).unwrap(), json!(false));
-        assert_eq!(to_value(HoverMode::XUnified).unwrap(), json!("x unified"));
-        assert_eq!(to_value(HoverMode::YUnified).unwrap(), json!("y unified"));
-    }
-
-    #[test]
-    fn serialize_bar_mode() {
-        assert_eq!(to_value(BarMode::Stack).unwrap(), json!("stack"));
-        assert_eq!(to_value(BarMode::Group).unwrap(), json!("group"));
-        assert_eq!(to_value(BarMode::Overlay).unwrap(), json!("overlay"));
-        assert_eq!(to_value(BarMode::Relative).unwrap(), json!("relative"));
-    }
-
-    #[test]
-    fn serialize_bar_norm() {
-        assert_eq!(to_value(BarNorm::Empty).unwrap(), json!(""));
-        assert_eq!(to_value(BarNorm::Fraction).unwrap(), json!("fraction"));
-        assert_eq!(to_value(BarNorm::Percent).unwrap(), json!("percent"));
-    }
-
-    #[test]
-    fn serialize_box_mode() {
-        assert_eq!(to_value(BoxMode::Group).unwrap(), json!("group"));
-        assert_eq!(to_value(BoxMode::Overlay).unwrap(), json!("overlay"));
-    }
-
-    #[test]
-    fn serialize_violin_mode() {
-        assert_eq!(to_value(ViolinMode::Group).unwrap(), json!("group"));
-        assert_eq!(to_value(ViolinMode::Overlay).unwrap(), json!("overlay"));
-    }
-
-    #[test]
-    fn serialize_waterfall_mode() {
-        assert_eq!(to_value(WaterfallMode::Group).unwrap(), json!("group"));
-        assert_eq!(to_value(WaterfallMode::Overlay).unwrap(), json!("overlay"));
-    }
-
     #[test]
     fn serialize_valign() {
         assert_eq!(to_value(VAlign::Top).unwrap(), json!("top"));
@@ -1105,51 +608,6 @@ mod tests {
         assert_eq!(to_value(ArrowSide::None).unwrap(), json!("none"));
     }
 
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_click_mode() {
-        assert_eq!(to_value(ClickMode::Event).unwrap(), json!("event"));
-        assert_eq!(to_value(ClickMode::Select).unwrap(), json!("select"));
-        assert_eq!(to_value(ClickMode::EventAndSelect).unwrap(), json!("event+select"));
-        assert_eq!(to_value(ClickMode::None).unwrap(), json!("none"));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_drag_mode() {
-        assert_eq!(to_value(DragMode::Zoom).unwrap(), json!("zoom"));
-        assert_eq!(to_value(DragMode::Pan).unwrap(), json!("pan"));
-        assert_eq!(to_value(DragMode::Select).unwrap(), json!("select"));
-        assert_eq!(to_value(DragMode::Lasso).unwrap(), json!("lasso"));
-        assert_eq!(to_value(DragMode::DrawClosedPath).unwrap(), json!("drawclosedpath"));
-        assert_eq!(to_value(DragMode::DrawOpenPath).unwrap(), json!("drawopenpath"));
-        assert_eq!(to_value(DragMode::DrawLine).unwrap(), json!("drawline"));
-        assert_eq!(to_value(DragMode::DrawRect).unwrap(), json!("drawrect"));
-        assert_eq!(to_value(DragMode::DrawCircle).unwrap(), json!("drawcircle"));
-        assert_eq!(to_value(DragMode::Orbit).unwrap(), json!("orbit"));
-        assert_eq!(to_value(DragMode::Turntable).unwrap(), json!("turntable"));
-        assert_eq!(to_value(DragMode::False).unwrap(), json!(false));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn serialize_mapbox_style() {
-        assert_eq!(to_value(MapboxStyle::CartoDarkMatter).unwrap(), json!("carto-darkmatter"));
-        assert_eq!(to_value(MapboxStyle::CartoPositron).unwrap(), json!("carto-positron"));
-        assert_eq!(to_value(MapboxStyle::OpenStreetMap).unwrap(), json!("open-street-map"));
-        assert_eq!(to_value(MapboxStyle::StamenTerrain).unwrap(), json!("stamen-terrain"));
-        assert_eq!(to_value(MapboxStyle::StamenToner).unwrap(), json!("stamen-toner"));
-        assert_eq!(to_value(MapboxStyle::StamenWatercolor).unwrap(), json!("stamen-watercolor"));
-        assert_eq!(to_value(MapboxStyle::WhiteBg).unwrap(), json!("white-bg"));
-        assert_eq!(to_value(MapboxStyle::Basic).unwrap(), json!("basic"));
-        assert_eq!(to_value(MapboxStyle::Streets).unwrap(), json!("streets"));
-        assert_eq!(to_value(MapboxStyle::Outdoors).unwrap(), json!("outdoors"));
-        assert_eq!(to_value(MapboxStyle::Light).unwrap(), json!("light"));
-        assert_eq!(to_value(MapboxStyle::Dark).unwrap(), json!("dark"));
-        assert_eq!(to_value(MapboxStyle::Satellite).unwrap(), json!("satellite"));
-        assert_eq!(to_value(MapboxStyle::SatelliteStreets).unwrap(), json!("satellite-streets"));
-    }
-
     #[test]
     fn serialize_select_direction() {
         assert_eq!(to_value(SelectDirection::Horizontal).unwrap(), json!("h"));
@@ -1441,183 +899,4 @@ mod tests {
 
         assert_eq!(to_value(layout).unwrap(), expected);
     }
-
-    #[test]
-    fn serialize_layout_scene() {
-        let layout = Layout::new().scene(
-            LayoutScene::new()
-                .x_axis(Axis::new())
-                .y_axis(Axis::new())
-                .z_axis(Axis::new())
-                .camera(Camera::new())
-                .aspect_mode(AspectMode::Auto)
-                .hover_mode(HoverMode::Closest)
-                .drag_mode(DragMode3D::Turntable)
-                .background_color("#FFFFFF")
-                .annotations(vec![Annotation::new()]),
-        );
-
-        let expected = json!({
-            "scene": {
-                "xaxis": {},
-                "yaxis": {},
-                "zaxis": {},
-                "camera": {},
-                "aspectmode": "auto",
-                "hovermode": "closest",
-                "dragmode": "turntable",
-                "bgcolor": "#FFFFFF",
-                "annotations": [{}],
-            }
-        });
-
-        assert_eq!(to_value(layout).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_eye() {
-        let eye = Eye::new();
-
-        assert_eq!(
-            to_value(eye).unwrap(),
-            json!({
-                "x": 1.25,
-                "y": 1.25,
-                "z": 1.25,
-            })
-        );
-
-        let eye = Eye::new().x(1f64).y(2f64).z(3f64);
-
-        let expected = json!({
-            "x": 1.0,
-            "y": 2.0,
-            "z": 3.0,
-        });
-
-        assert_eq!(to_value(eye).unwrap(), expected);
-
-        let eye: Eye = (1f64, 2f64, 3f64).into();
-
-        assert_eq!(to_value(eye).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_projection() {
-        let projection = Projection::new().projection_type(ProjectionType::default());
-
-        let expected = json!({
-            "type": "perspective",
-        });
-
-        assert_eq!(to_value(projection).unwrap(), expected);
-
-        let projection = Projection::new().projection_type(ProjectionType::Orthographic);
-
-        let expected = json!({
-            "type": "orthographic",
-        });
-
-        assert_eq!(to_value(projection).unwrap(), expected);
-
-        let projection: Projection = ProjectionType::Orthographic.into();
-
-        assert_eq!(to_value(projection).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_camera_center() {
-        let camera_center = CameraCenter::new();
-
-        let expected = json!({
-            "x": 0.0,
-            "y": 0.0,
-            "z": 0.0,
-        });
-
-        assert_eq!(to_value(camera_center).unwrap(), expected);
-
-        let camera_center = CameraCenter::new().x(1f64).y(2f64).z(3f64);
-
-        let expected = json!({
-            "x": 1.0,
-            "y": 2.0,
-            "z": 3.0,
-        });
-
-        assert_eq!(to_value(camera_center).unwrap(), expected);
-
-        let camera_center: CameraCenter = (1f64, 2f64, 3f64).into();
-
-        assert_eq!(to_value(camera_center).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_aspect_ratio() {
-        let aspect_ratio = AspectRatio::new();
-
-        let expected = json!({
-            "x": 1.0,
-            "y": 1.0,
-            "z": 1.0,
-        });
-
-        assert_eq!(to_value(aspect_ratio).unwrap(), expected);
-
-        let aspect_ratio = AspectRatio::new().x(1f64).y(2f64).z(3f64);
-
-        let expected = json!({
-            "x": 1.0,
-            "y": 2.0,
-            "z": 3.0,
-        });
-
-        assert_eq!(to_value(aspect_ratio).unwrap(), expected);
-
-        let aspect_ratio: AspectRatio = (1f64, 2f64, 3f64).into();
-
-        assert_eq!(to_value(aspect_ratio).unwrap(), expected);
-    }
-
-    #[test]
-    fn serialize_aspect_mode() {
-        let aspect_mode = AspectMode::default();
-
-        assert_eq!(to_value(aspect_mode).unwrap(), json!("auto"));
-
-        let aspect_mode = AspectMode::Data;
-
-        assert_eq!(to_value(aspect_mode).unwrap(), json!("data"));
-
-        let aspect_mode = AspectMode::Cube;
-
-        assert_eq!(to_value(aspect_mode).unwrap(), json!("cube"));
-    }
-
-    #[test]
-    fn serialize_up() {
-        let up = Up::new();
-
-        let expected = json!({
-            "x": 0.0,
-            "y": 0.0,
-            "z": 1.0,
-        });
-
-        assert_eq!(to_value(up).unwrap(), expected);
-
-        let up = Up::new().x(1f64).y(2f64).z(3f64);
-
-        let expected = json!({
-            "x": 1.0,
-            "y": 2.0,
-            "z": 3.0,
-        });
-
-        assert_eq!(to_value(up).unwrap(), expected);
-
-        let up: Up = (1f64, 2f64, 3f64).into();
-
-        assert_eq!(to_value(up).unwrap(), expected);
-    }
 }
diff --git a/plotly/src/layout/modes.rs b/plotly/src/layout/modes.rs
new file mode 100644
index 00000000..8de9de13
--- /dev/null
+++ b/plotly/src/layout/modes.rs
@@ -0,0 +1,126 @@
+use serde::{Serialize, Serializer};
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum BoxMode {
+    Group,
+    Overlay,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum BarMode {
+    Stack,
+    Group,
+    Overlay,
+    Relative,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum BarNorm {
+    #[serde(rename = "")]
+    Empty,
+    Fraction,
+    Percent,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ClickMode {
+    Event,
+    Select,
+    #[serde(rename = "event+select")]
+    EventAndSelect,
+    None,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum ViolinMode {
+    Group,
+    Overlay,
+}
+
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum WaterfallMode {
+    Group,
+    Overlay,
+}
+
+#[derive(Debug, Clone)]
+pub enum UniformTextMode {
+    False,
+    Hide,
+    Show,
+}
+
+impl Serialize for UniformTextMode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            Self::False => serializer.serialize_bool(false),
+            Self::Hide => serializer.serialize_str("hide"),
+            Self::Show => serializer.serialize_str("show"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_click_mode() {
+        assert_eq!(to_value(ClickMode::Event).unwrap(), json!("event"));
+        assert_eq!(to_value(ClickMode::Select).unwrap(), json!("select"));
+        assert_eq!(to_value(ClickMode::EventAndSelect).unwrap(), json!("event+select"));
+        assert_eq!(to_value(ClickMode::None).unwrap(), json!("none"));
+    }
+
+    #[test]
+    fn serialize_uniform_text_mode() {
+        assert_eq!(to_value(UniformTextMode::False).unwrap(), json!(false));
+        assert_eq!(to_value(UniformTextMode::Hide).unwrap(), json!("hide"));
+        assert_eq!(to_value(UniformTextMode::Show).unwrap(), json!("show"));
+    }
+
+    #[test]
+    fn serialize_bar_mode() {
+        assert_eq!(to_value(BarMode::Stack).unwrap(), json!("stack"));
+        assert_eq!(to_value(BarMode::Group).unwrap(), json!("group"));
+        assert_eq!(to_value(BarMode::Overlay).unwrap(), json!("overlay"));
+        assert_eq!(to_value(BarMode::Relative).unwrap(), json!("relative"));
+    }
+
+    #[test]
+    fn serialize_bar_norm() {
+        assert_eq!(to_value(BarNorm::Empty).unwrap(), json!(""));
+        assert_eq!(to_value(BarNorm::Fraction).unwrap(), json!("fraction"));
+        assert_eq!(to_value(BarNorm::Percent).unwrap(), json!("percent"));
+    }
+
+    #[test]
+    fn serialize_box_mode() {
+        assert_eq!(to_value(BoxMode::Group).unwrap(), json!("group"));
+        assert_eq!(to_value(BoxMode::Overlay).unwrap(), json!("overlay"));
+    }
+
+    #[test]
+    fn serialize_violin_mode() {
+        assert_eq!(to_value(ViolinMode::Group).unwrap(), json!("group"));
+        assert_eq!(to_value(ViolinMode::Overlay).unwrap(), json!("overlay"));
+    }
+
+    #[test]
+    fn serialize_waterfall_mode() {
+        assert_eq!(to_value(WaterfallMode::Group).unwrap(), json!("group"));
+        assert_eq!(to_value(WaterfallMode::Overlay).unwrap(), json!("overlay"));
+    }
+}
diff --git a/plotly/src/layout/scene.rs b/plotly/src/layout/scene.rs
new file mode 100644
index 00000000..523bcb4c
--- /dev/null
+++ b/plotly/src/layout/scene.rs
@@ -0,0 +1,538 @@
+use plotly_derive::FieldSetter;
+use serde::Serialize;
+
+use crate::color::Color;
+use crate::layout::{Annotation, Axis};
+
+#[derive(Serialize, Debug, Clone)]
+/// If "cube", this scene's axes are drawn as a cube, regardless of the axes'
+/// ranges. If "data", this scene's axes are drawn in proportion with the axes'
+/// ranges. If "manual", this scene's axes are drawn in proportion with the
+/// input of "aspectratio" (the default behavior if "aspectratio" is provided).
+/// If "auto", this scene's axes are drawn using the results of "data" except
+/// when one axis is more than four times the size of the two others, where in
+/// that case the results of "cube" are used.
+/// Default: "auto"
+#[derive(Default)]
+pub enum AspectMode {
+    #[serde(rename = "auto")]
+    #[default]
+    Auto,
+    #[serde(rename = "cube")]
+    Cube,
+    #[serde(rename = "data")]
+    Data,
+    #[serde(rename = "manual")]
+    Manual,
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+/// Sets this scene's axis aspectratio.
+/// x, y, z must be positive.
+/// Default: {x: 1, y: 1, z: 1}
+pub struct AspectRatio {
+    x: Option<f64>,
+    y: Option<f64>,
+    z: Option<f64>,
+}
+
+impl AspectRatio {
+    pub fn new() -> Self {
+        AspectRatio {
+            x: Some(1.0),
+            y: Some(1.0),
+            z: Some(1.0),
+        }
+    }
+}
+
+impl From<(f64, f64, f64)> for AspectRatio {
+    fn from((x, y, z): (f64, f64, f64)) -> Self {
+        AspectRatio {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+        }
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+/// Container for CameraCenter, Eye, Up, and Projection objects. The camera of a
+/// 3D scene.
+pub struct Camera {
+    center: Option<CameraCenter>,
+    eye: Option<Eye>,
+    up: Option<Up>,
+    projection: Option<Projection>,
+}
+
+impl Camera {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+/// Sets the (x, y, z) components of the 'center' camera vector. This vector
+/// determines the translation (x, y, z) space about the center of this scene.
+/// Default: {x: 0, y: 0, z: 0} which means that the center of the scene is at
+/// the origin.
+pub struct CameraCenter {
+    x: Option<f64>,
+    y: Option<f64>,
+    z: Option<f64>,
+}
+
+impl CameraCenter {
+    pub fn new() -> Self {
+        CameraCenter {
+            x: Some(0.0),
+            y: Some(0.0),
+            z: Some(0.0),
+        }
+    }
+}
+
+impl From<(f64, f64, f64)> for CameraCenter {
+    fn from((x, y, z): (f64, f64, f64)) -> Self {
+        CameraCenter {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+        }
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+/// Sets the (x, y, z) components of the 'eye' camera vector. This vector
+/// determines the view point about the origin of this scene.
+/// Default: {x: 1.25, y: 1.25, z: 1.25}
+pub struct Eye {
+    x: Option<f64>,
+    y: Option<f64>,
+    z: Option<f64>,
+}
+
+impl Eye {
+    pub fn new() -> Self {
+        Eye {
+            x: Some(1.25),
+            y: Some(1.25),
+            z: Some(1.25),
+        }
+    }
+}
+
+impl From<(f64, f64, f64)> for Eye {
+    fn from((x, y, z): (f64, f64, f64)) -> Self {
+        Eye {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+        }
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+/// Sets the (x, y, z) components of the 'up' camera vector. This vector
+/// determines the up direction of this scene with respect to the page. The
+/// Default: {x: 0, y: 0, z: 1} which means that the z axis points up.
+pub struct Up {
+    x: Option<f64>,
+    y: Option<f64>,
+    z: Option<f64>,
+}
+
+impl Up {
+    pub fn new() -> Self {
+        Up {
+            x: Some(0.0),
+            y: Some(0.0),
+            z: Some(1.0),
+        }
+    }
+}
+
+impl From<(f64, f64, f64)> for Up {
+    fn from((x, y, z): (f64, f64, f64)) -> Self {
+        Up {
+            x: Some(x),
+            y: Some(y),
+            z: Some(z),
+        }
+    }
+}
+
+/// Sets the projection type. The projection type could be either "perspective"
+/// or "orthographic".
+/// Default: "perspective"
+#[derive(Default, Serialize, Debug, Clone)]
+pub enum ProjectionType {
+    #[default]
+    #[serde(rename = "perspective")]
+    Perspective,
+    #[serde(rename = "orthographic")]
+    Orthographic,
+}
+
+impl From<ProjectionType> for Projection {
+    fn from(projection_type: ProjectionType) -> Self {
+        Projection {
+            projection_type: Some(projection_type),
+        }
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+/// Container for Projection options.
+pub struct Projection {
+    #[serde(rename = "type")]
+    projection_type: Option<ProjectionType>,
+}
+
+impl Projection {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum DragMode {
+    Zoom,
+    Pan,
+    Select,
+    Lasso,
+    DrawClosedPath,
+    DrawOpenPath,
+    DrawLine,
+    DrawRect,
+    DrawCircle,
+    Orbit,
+    Turntable,
+    False,
+}
+
+impl Serialize for DragMode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match *self {
+            Self::Zoom => serializer.serialize_str("zoom"),
+            Self::Pan => serializer.serialize_str("pan"),
+            Self::Select => serializer.serialize_str("select"),
+            Self::Lasso => serializer.serialize_str("lasso"),
+            Self::DrawClosedPath => serializer.serialize_str("drawclosedpath"),
+            Self::DrawOpenPath => serializer.serialize_str("drawopenpath"),
+            Self::DrawLine => serializer.serialize_str("drawline"),
+            Self::DrawRect => serializer.serialize_str("drawrect"),
+            Self::DrawCircle => serializer.serialize_str("drawcircle"),
+            Self::Orbit => serializer.serialize_str("orbit"),
+            Self::Turntable => serializer.serialize_str("turntable"),
+            Self::False => serializer.serialize_bool(false),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+/// Determines the mode of drag interactions.
+pub enum DragMode3D {
+    Zoom,
+    Pan,
+    Turntable,
+    Orbit,
+    False,
+}
+
+impl Serialize for DragMode3D {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match *self {
+            Self::Zoom => serializer.serialize_str("zoom"),
+            Self::Pan => serializer.serialize_str("pan"),
+            Self::Turntable => serializer.serialize_str("turntable"),
+            Self::Orbit => serializer.serialize_str("orbit"),
+            Self::False => serializer.serialize_bool(false),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum HoverMode {
+    X,
+    Y,
+    Closest,
+    False,
+    XUnified,
+    YUnified,
+}
+
+impl Serialize for HoverMode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match *self {
+            Self::X => serializer.serialize_str("x"),
+            Self::Y => serializer.serialize_str("y"),
+            Self::Closest => serializer.serialize_str("closest"),
+            Self::False => serializer.serialize_bool(false),
+            Self::XUnified => serializer.serialize_str("x unified"),
+            Self::YUnified => serializer.serialize_str("y unified"),
+        }
+    }
+}
+
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Debug, Clone, FieldSetter)]
+/// 3D scene layout
+pub struct LayoutScene {
+    #[serde(rename = "bgcolor")]
+    background_color: Option<Box<dyn Color>>,
+    camera: Option<Camera>,
+    #[serde(rename = "aspectmode")]
+    aspect_mode: Option<AspectMode>,
+    #[serde(rename = "aspectratio")]
+    aspect_ratio: Option<AspectRatio>,
+    #[serde(rename = "xaxis")]
+    x_axis: Option<Axis>,
+    #[serde(rename = "yaxis")]
+    y_axis: Option<Axis>,
+    #[serde(rename = "zaxis")]
+    z_axis: Option<Axis>,
+    #[serde(rename = "dragmode")]
+    drag_mode: Option<DragMode3D>,
+    #[serde(rename = "hovermode")]
+    hover_mode: Option<HoverMode>,
+    annotations: Option<Vec<Annotation>>,
+    // domain: Domain,
+    // uirevision: Uirevision,
+}
+
+impl LayoutScene {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, to_value};
+
+    use super::*;
+    use crate::layout::Layout;
+
+    #[test]
+    fn serialize_hover_mode() {
+        assert_eq!(to_value(HoverMode::X).unwrap(), json!("x"));
+        assert_eq!(to_value(HoverMode::Y).unwrap(), json!("y"));
+        assert_eq!(to_value(HoverMode::Closest).unwrap(), json!("closest"));
+        assert_eq!(to_value(HoverMode::False).unwrap(), json!(false));
+        assert_eq!(to_value(HoverMode::XUnified).unwrap(), json!("x unified"));
+        assert_eq!(to_value(HoverMode::YUnified).unwrap(), json!("y unified"));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_drag_mode() {
+        assert_eq!(to_value(DragMode::Zoom).unwrap(), json!("zoom"));
+        assert_eq!(to_value(DragMode::Pan).unwrap(), json!("pan"));
+        assert_eq!(to_value(DragMode::Select).unwrap(), json!("select"));
+        assert_eq!(to_value(DragMode::Lasso).unwrap(), json!("lasso"));
+        assert_eq!(to_value(DragMode::DrawClosedPath).unwrap(), json!("drawclosedpath"));
+        assert_eq!(to_value(DragMode::DrawOpenPath).unwrap(), json!("drawopenpath"));
+        assert_eq!(to_value(DragMode::DrawLine).unwrap(), json!("drawline"));
+        assert_eq!(to_value(DragMode::DrawRect).unwrap(), json!("drawrect"));
+        assert_eq!(to_value(DragMode::DrawCircle).unwrap(), json!("drawcircle"));
+        assert_eq!(to_value(DragMode::Orbit).unwrap(), json!("orbit"));
+        assert_eq!(to_value(DragMode::Turntable).unwrap(), json!("turntable"));
+        assert_eq!(to_value(DragMode::False).unwrap(), json!(false));
+    }
+
+    #[test]
+    fn serialize_aspect_ratio() {
+        let aspect_ratio = AspectRatio::new();
+
+        let expected = json!({
+            "x": 1.0,
+            "y": 1.0,
+            "z": 1.0,
+        });
+
+        assert_eq!(to_value(aspect_ratio).unwrap(), expected);
+
+        let aspect_ratio = AspectRatio::new().x(1f64).y(2f64).z(3f64);
+
+        let expected = json!({
+            "x": 1.0,
+            "y": 2.0,
+            "z": 3.0,
+        });
+
+        assert_eq!(to_value(aspect_ratio).unwrap(), expected);
+
+        let aspect_ratio: AspectRatio = (1f64, 2f64, 3f64).into();
+
+        assert_eq!(to_value(aspect_ratio).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_layout_scene() {
+        let layout = Layout::new().scene(
+            LayoutScene::new()
+                .x_axis(Axis::new())
+                .y_axis(Axis::new())
+                .z_axis(Axis::new())
+                .camera(Camera::new())
+                .aspect_mode(AspectMode::Auto)
+                .hover_mode(HoverMode::Closest)
+                .drag_mode(DragMode3D::Turntable)
+                .background_color("#FFFFFF")
+                .annotations(vec![Annotation::new()]),
+        );
+
+        let expected = json!({
+            "scene": {
+                "xaxis": {},
+                "yaxis": {},
+                "zaxis": {},
+                "camera": {},
+                "aspectmode": "auto",
+                "hovermode": "closest",
+                "dragmode": "turntable",
+                "bgcolor": "#FFFFFF",
+                "annotations": [{}],
+            }
+        });
+
+        assert_eq!(to_value(layout).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_eye() {
+        let eye = Eye::new();
+
+        assert_eq!(
+            to_value(eye).unwrap(),
+            json!({
+                "x": 1.25,
+                "y": 1.25,
+                "z": 1.25,
+            })
+        );
+
+        let eye = Eye::new().x(1f64).y(2f64).z(3f64);
+
+        let expected = json!({
+            "x": 1.0,
+            "y": 2.0,
+            "z": 3.0,
+        });
+
+        assert_eq!(to_value(eye).unwrap(), expected);
+
+        let eye: Eye = (1f64, 2f64, 3f64).into();
+
+        assert_eq!(to_value(eye).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_projection() {
+        let projection = Projection::new().projection_type(ProjectionType::default());
+
+        let expected = json!({
+            "type": "perspective",
+        });
+
+        assert_eq!(to_value(projection).unwrap(), expected);
+
+        let projection = Projection::new().projection_type(ProjectionType::Orthographic);
+
+        let expected = json!({
+            "type": "orthographic",
+        });
+
+        assert_eq!(to_value(projection).unwrap(), expected);
+
+        let projection: Projection = ProjectionType::Orthographic.into();
+
+        assert_eq!(to_value(projection).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_camera_center() {
+        let camera_center = CameraCenter::new();
+
+        let expected = json!({
+            "x": 0.0,
+            "y": 0.0,
+            "z": 0.0,
+        });
+
+        assert_eq!(to_value(camera_center).unwrap(), expected);
+
+        let camera_center = CameraCenter::new().x(1f64).y(2f64).z(3f64);
+
+        let expected = json!({
+            "x": 1.0,
+            "y": 2.0,
+            "z": 3.0,
+        });
+
+        assert_eq!(to_value(camera_center).unwrap(), expected);
+
+        let camera_center: CameraCenter = (1f64, 2f64, 3f64).into();
+
+        assert_eq!(to_value(camera_center).unwrap(), expected);
+    }
+
+    #[test]
+    fn serialize_aspect_mode() {
+        let aspect_mode = AspectMode::default();
+
+        assert_eq!(to_value(aspect_mode).unwrap(), json!("auto"));
+
+        let aspect_mode = AspectMode::Data;
+
+        assert_eq!(to_value(aspect_mode).unwrap(), json!("data"));
+
+        let aspect_mode = AspectMode::Cube;
+
+        assert_eq!(to_value(aspect_mode).unwrap(), json!("cube"));
+    }
+
+    #[test]
+    fn serialize_up() {
+        let up = Up::new();
+
+        let expected = json!({
+            "x": 0.0,
+            "y": 0.0,
+            "z": 1.0,
+        });
+
+        assert_eq!(to_value(up).unwrap(), expected);
+
+        let up = Up::new().x(1f64).y(2f64).z(3f64);
+
+        let expected = json!({
+            "x": 1.0,
+            "y": 2.0,
+            "z": 3.0,
+        });
+
+        assert_eq!(to_value(up).unwrap(), expected);
+
+        let up: Up = (1f64, 2f64, 3f64).into();
+
+        assert_eq!(to_value(up).unwrap(), expected);
+    }
+}

From 1a85963c4c2bfd3f3aa9d12f819f3a4fde04a429 Mon Sep 17 00:00:00 2001
From: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
Date: Wed, 4 Jun 2025 10:43:13 +0200
Subject: [PATCH 7/8] uniformize layout and layouttemplate

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
---
 plotly/src/layout/mapbox.rs |  1 +
 plotly/src/layout/mod.rs    | 56 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/plotly/src/layout/mapbox.rs b/plotly/src/layout/mapbox.rs
index b53e3979..3baa62a0 100644
--- a/plotly/src/layout/mapbox.rs
+++ b/plotly/src/layout/mapbox.rs
@@ -40,6 +40,7 @@ pub enum MapboxStyle {
     SatelliteStreets,
 }
 
+#[serde_with::skip_serializing_none]
 #[derive(Serialize, Clone, Debug, FieldSetter)]
 pub struct Mapbox {
     /// Sets the mapbox access token to be used for this mapbox map. Note that
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index d2093828..404e6d09 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -226,34 +226,57 @@ pub struct LayoutTemplate {
     x_axis: Option<Box<Axis>>,
     #[serde(rename = "yaxis")]
     y_axis: Option<Box<Axis>>,
+    #[serde(rename = "zaxis")]
+    z_axis: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis2")]
     x_axis2: Option<Box<Axis>>,
     #[serde(rename = "yaxis2")]
     y_axis2: Option<Box<Axis>>,
+    #[serde(rename = "zaxis2")]
+    z_axis2: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis3")]
     x_axis3: Option<Box<Axis>>,
     #[serde(rename = "yaxis3")]
     y_axis3: Option<Box<Axis>>,
+    #[serde(rename = "zaxis3")]
+    z_axis3: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis4")]
     x_axis4: Option<Box<Axis>>,
     #[serde(rename = "yaxis4")]
     y_axis4: Option<Box<Axis>>,
+    #[serde(rename = "zaxis4")]
+    z_axis4: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis5")]
     x_axis5: Option<Box<Axis>>,
     #[serde(rename = "yaxis5")]
     y_axis5: Option<Box<Axis>>,
+    #[serde(rename = "zaxis5")]
+    z_axis5: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis6")]
     x_axis6: Option<Box<Axis>>,
     #[serde(rename = "yaxis6")]
     y_axis6: Option<Box<Axis>>,
+    #[serde(rename = "zaxis6")]
+    z_axis6: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis7")]
     x_axis7: Option<Box<Axis>>,
     #[serde(rename = "yaxis7")]
     y_axis7: Option<Box<Axis>>,
+    #[serde(rename = "zaxis7")]
+    z_axis7: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis8")]
     x_axis8: Option<Box<Axis>>,
     #[serde(rename = "yaxis8")]
     y_axis8: Option<Box<Axis>>,
+    #[serde(rename = "zaxis8")]
+    z_axis8: Option<Box<Axis>>,
 
     // ternary: Option<LayoutTernary>,
     scene: Option<LayoutScene>,
@@ -304,6 +327,11 @@ pub struct LayoutTemplate {
     sunburst_colorway: Option<Vec<Box<dyn Color>>>,
     #[serde(rename = "extendsunburstcolors")]
     extend_sunburst_colors: Option<bool>,
+
+    mapbox: Option<Mapbox>,
+
+    #[serde(rename = "updatemenus")]
+    update_menus: Option<Vec<UpdateMenu>>,
 }
 
 impl LayoutTemplate {
@@ -402,30 +430,35 @@ pub struct Layout {
     y_axis2: Option<Box<Axis>>,
     #[serde(rename = "zaxis2")]
     z_axis2: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis3")]
     x_axis3: Option<Box<Axis>>,
     #[serde(rename = "yaxis3")]
     y_axis3: Option<Box<Axis>>,
     #[serde(rename = "zaxis3")]
     z_axis3: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis4")]
     x_axis4: Option<Box<Axis>>,
     #[serde(rename = "yaxis4")]
     y_axis4: Option<Box<Axis>>,
     #[serde(rename = "zaxis4")]
     z_axis4: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis5")]
     x_axis5: Option<Box<Axis>>,
     #[serde(rename = "yaxis5")]
     y_axis5: Option<Box<Axis>>,
     #[serde(rename = "zaxis5")]
     z_axis5: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis6")]
     x_axis6: Option<Box<Axis>>,
     #[serde(rename = "yaxis6")]
     y_axis6: Option<Box<Axis>>,
     #[serde(rename = "zaxis6")]
     z_axis6: Option<Box<Axis>>,
+
     #[serde(rename = "xaxis7")]
     x_axis7: Option<Box<Axis>>,
     #[serde(rename = "yaxis7")]
@@ -433,6 +466,7 @@ pub struct Layout {
     #[serde(rename = "zaxis7")]
     z_axis7: Option<Box<Axis>>,
     #[serde(rename = "xaxis8")]
+
     x_axis8: Option<Box<Axis>>,
     #[serde(rename = "yaxis8")]
     y_axis8: Option<Box<Axis>>,
@@ -660,6 +694,14 @@ mod tests {
             .y_axis6(Axis::new())
             .y_axis7(Axis::new())
             .y_axis8(Axis::new())
+            .z_axis(Axis::new())
+            .z_axis2(Axis::new())
+            .z_axis3(Axis::new())
+            .z_axis4(Axis::new())
+            .z_axis5(Axis::new())
+            .z_axis6(Axis::new())
+            .z_axis7(Axis::new())
+            .z_axis8(Axis::new())
             .annotations(vec![Annotation::new()])
             .shapes(vec![Shape::new()])
             .new_shape(NewShape::new())
@@ -680,7 +722,9 @@ mod tests {
             .pie_colorway(vec!["#789789"])
             .extend_pie_colors(true)
             .sunburst_colorway(vec!["#654654"])
-            .extend_sunburst_colors(false);
+            .extend_sunburst_colors(false)
+            .mapbox(Mapbox::new())
+            .update_menus(vec![UpdateMenu::new()]);
 
         let expected = json!({
             "title": {"text": "Title"},
@@ -724,6 +768,14 @@ mod tests {
             "yaxis6": {},
             "yaxis7": {},
             "yaxis8": {},
+            "zaxis": {},
+            "zaxis2": {},
+            "zaxis3": {},
+            "zaxis4": {},
+            "zaxis5": {},
+            "zaxis6": {},
+            "zaxis7": {},
+            "zaxis8": {},
             "annotations": [{}],
             "shapes": [{}],
             "newshape": {},
@@ -745,6 +797,8 @@ mod tests {
             "extendpiecolors": true,
             "sunburstcolorway": ["#654654"],
             "extendsunburstcolors": false,
+            "mapbox": {},
+            "updatemenus": [{}],
         });
 
         assert_eq!(to_value(layout_template).unwrap(), expected);

From 2a9c4ed65a887ab25db161c7d89a394aabc57dbf Mon Sep 17 00:00:00 2001
From: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
Date: Wed, 4 Jun 2025 12:33:08 +0200
Subject: [PATCH 8/8] refactored layout and layouttemplate generation using a
 proc macro

Signed-off-by: Andrei Gherghescu <8067229+andrei-ng@users.noreply.github.com>
---
 plotly/Cargo.toml           |   8 +-
 plotly/src/layout/mapbox.rs |   3 +-
 plotly/src/layout/mod.rs    | 279 +++---------------------------------
 plotly/src/layout/modes.rs  |  37 +++++
 plotly/src/layout/scene.rs  |  39 +----
 plotly_derive/src/lib.rs    |  87 ++++++++++-
 6 files changed, 151 insertions(+), 302 deletions(-)

diff --git a/plotly/Cargo.toml b/plotly/Cargo.toml
index 2340ef10..92d669f1 100644
--- a/plotly/Cargo.toml
+++ b/plotly/Cargo.toml
@@ -40,8 +40,12 @@ rand = "0.9"
 getrandom = { version = "0.3", features = ["wasm_js"] }
 wasm-bindgen-futures = { version = "0.4" }
 wasm-bindgen = { version = "0.2" }
-serde-wasm-bindgen = {version = "0.6.3"}
-web-sys = { version = "0.3.77", features = ["Document", "Window", "HtmlElement"]}
+serde-wasm-bindgen = { version = "0.6.3" }
+web-sys = { version = "0.3.77", features = [
+    "Document",
+    "Window",
+    "HtmlElement",
+] }
 
 [dev-dependencies]
 csv = "1.1"
diff --git a/plotly/src/layout/mapbox.rs b/plotly/src/layout/mapbox.rs
index 3baa62a0..57213bbd 100644
--- a/plotly/src/layout/mapbox.rs
+++ b/plotly/src/layout/mapbox.rs
@@ -73,9 +73,10 @@ impl Mapbox {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use serde_json::{json, to_value};
 
+    use super::*;
+
     #[test]
     #[rustfmt::skip]
     fn serialize_mapbox_style() {
diff --git a/plotly/src/layout/mod.rs b/plotly/src/layout/mod.rs
index 404e6d09..ddf3cf82 100644
--- a/plotly/src/layout/mod.rs
+++ b/plotly/src/layout/mod.rs
@@ -1,12 +1,12 @@
-use serde::Serialize;
 use std::borrow::Cow;
-use update_menu::UpdateMenu;
 
-use crate::{
-    color::Color,
-    common::{Calendar, ColorScale, Font, Label, Orientation, Title},
-};
+use plotly_derive::layout_structs;
 use plotly_derive::FieldSetter;
+use serde::Serialize;
+use update_menu::UpdateMenu;
+
+use crate::color::Color;
+use crate::common::{Calendar, ColorScale, Font, Label, Orientation, Title};
 
 pub mod themes;
 pub mod update_menu;
@@ -29,11 +29,13 @@ pub use self::axis::{
 };
 pub use self::grid::{GridDomain, GridPattern, GridXSide, GridYSide, LayoutGrid, RowOrder};
 pub use self::legend::{Legend, TraceOrder};
-pub use self::mapbox::{Mapbox, MapboxStyle};
+pub use self::mapbox::{Center, Mapbox, MapboxStyle};
 pub use self::modes::{
-    BarMode, BarNorm, BoxMode, ClickMode, UniformTextMode, ViolinMode, WaterfallMode,
+    AspectMode, BarMode, BarNorm, BoxMode, ClickMode, UniformTextMode, ViolinMode, WaterfallMode,
+};
+pub use self::scene::{
+    Camera, CameraCenter, DragMode, DragMode3D, HoverMode, LayoutScene, Projection, ProjectionType,
 };
-pub use self::scene::{DragMode, DragMode3D, HoverMode, LayoutScene, Projection, ProjectionType};
 pub use self::shape::{
     ActiveShape, DrawDirection, FillRule, NewShape, Shape, ShapeLayer, ShapeLine, ShapeSizeMode,
     ShapeType,
@@ -161,203 +163,14 @@ impl Into<Cow<'static, Template>> for &'static Template {
     }
 }
 
-// LayoutTemplate matches Layout except it lacks a field for template
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-pub struct LayoutTemplate {
-    title: Option<Title>,
-    #[serde(rename = "showlegend")]
-    show_legend: Option<bool>,
-    legend: Option<Legend>,
-    margin: Option<Margin>,
-    #[serde(rename = "autosize")]
-    auto_size: Option<bool>,
-    width: Option<usize>,
-    height: Option<usize>,
-    font: Option<Font>,
-    #[serde(rename = "uniformtext")]
-    uniform_text: Option<UniformText>,
-    separators: Option<String>,
-    #[serde(rename = "paper_bgcolor")]
-    paper_background_color: Option<Box<dyn Color>>,
-    #[serde(rename = "plot_bgcolor")]
-    plot_background_color: Option<Box<dyn Color>>,
-    #[serde(rename = "colorscale")]
-    color_scale: Option<LayoutColorScale>,
-    colorway: Option<Vec<Box<dyn Color>>>,
-    #[serde(rename = "coloraxis")]
-    color_axis: Option<ColorAxis>,
-    #[serde(rename = "modebar")]
-    mode_bar: Option<ModeBar>,
-    /// Determines the mode of hover interactions. If "closest", a single
-    /// hoverlabel will appear for the "closest" point within the
-    /// `hoverdistance`. If "x" (or "y"), multiple hoverlabels will appear for
-    /// multiple points at the "closest" x- (or y-) coordinate within the
-    /// `hoverdistance`, with the caveat that no more than one hoverlabel
-    /// will appear per trace. If "x unified" (or "y unified"), a single
-    /// hoverlabel will appear multiple points at the closest x- (or y-)
-    /// coordinate within the `hoverdistance` with the caveat that no more than
-    /// one hoverlabel will appear per trace. In this mode, spikelines are
-    /// enabled by default perpendicular to the specified axis.
-    /// If false, hover interactions are disabled. If `clickmode` includes the
-    /// "select" flag, `hovermode` defaults to "closest". If `clickmode`
-    /// lacks the "select" flag, it defaults to "x" or "y" (depending on the
-    /// trace's `orientation` value) for plots based on cartesian coordinates.
-    /// For anything else the default value is "closest".
-    #[serde(rename = "hovermode")]
-    hover_mode: Option<HoverMode>,
-    #[serde(rename = "clickmode")]
-    click_mode: Option<ClickMode>,
-    #[serde(rename = "dragmode")]
-    drag_mode: Option<DragMode>,
-    #[serde(rename = "selectdirection")]
-    select_direction: Option<SelectDirection>,
-    #[serde(rename = "hoverdistance")]
-    hover_distance: Option<i32>,
-    #[serde(rename = "spikedistance")]
-    spike_distance: Option<i32>,
-    #[serde(rename = "hoverlabel")]
-    hover_label: Option<Label>,
-
-    grid: Option<LayoutGrid>,
-    calendar: Option<Calendar>,
-
-    #[serde(rename = "xaxis")]
-    x_axis: Option<Box<Axis>>,
-    #[serde(rename = "yaxis")]
-    y_axis: Option<Box<Axis>>,
-    #[serde(rename = "zaxis")]
-    z_axis: Option<Box<Axis>>,
-
-    #[serde(rename = "xaxis2")]
-    x_axis2: Option<Box<Axis>>,
-    #[serde(rename = "yaxis2")]
-    y_axis2: Option<Box<Axis>>,
-    #[serde(rename = "zaxis2")]
-    z_axis2: Option<Box<Axis>>,
-
-    #[serde(rename = "xaxis3")]
-    x_axis3: Option<Box<Axis>>,
-    #[serde(rename = "yaxis3")]
-    y_axis3: Option<Box<Axis>>,
-    #[serde(rename = "zaxis3")]
-    z_axis3: Option<Box<Axis>>,
-
-    #[serde(rename = "xaxis4")]
-    x_axis4: Option<Box<Axis>>,
-    #[serde(rename = "yaxis4")]
-    y_axis4: Option<Box<Axis>>,
-    #[serde(rename = "zaxis4")]
-    z_axis4: Option<Box<Axis>>,
-
-    #[serde(rename = "xaxis5")]
-    x_axis5: Option<Box<Axis>>,
-    #[serde(rename = "yaxis5")]
-    y_axis5: Option<Box<Axis>>,
-    #[serde(rename = "zaxis5")]
-    z_axis5: Option<Box<Axis>>,
-
-    #[serde(rename = "xaxis6")]
-    x_axis6: Option<Box<Axis>>,
-    #[serde(rename = "yaxis6")]
-    y_axis6: Option<Box<Axis>>,
-    #[serde(rename = "zaxis6")]
-    z_axis6: Option<Box<Axis>>,
-
-    #[serde(rename = "xaxis7")]
-    x_axis7: Option<Box<Axis>>,
-    #[serde(rename = "yaxis7")]
-    y_axis7: Option<Box<Axis>>,
-    #[serde(rename = "zaxis7")]
-    z_axis7: Option<Box<Axis>>,
-
-    #[serde(rename = "xaxis8")]
-    x_axis8: Option<Box<Axis>>,
-    #[serde(rename = "yaxis8")]
-    y_axis8: Option<Box<Axis>>,
-    #[serde(rename = "zaxis8")]
-    z_axis8: Option<Box<Axis>>,
-
-    // ternary: Option<LayoutTernary>,
-    scene: Option<LayoutScene>,
-    // polar: Option<LayoutPolar>,
-    annotations: Option<Vec<Annotation>>,
-    shapes: Option<Vec<Shape>>,
-    #[serde(rename = "newshape")]
-    new_shape: Option<NewShape>,
-    #[serde(rename = "activeshape")]
-    active_shape: Option<ActiveShape>,
-
-    #[serde(rename = "boxmode")]
-    box_mode: Option<BoxMode>,
-    #[serde(rename = "boxgap")]
-    box_gap: Option<f64>,
-    #[serde(rename = "boxgroupgap")]
-    box_group_gap: Option<f64>,
-
-    #[serde(rename = "barmode")]
-    bar_mode: Option<BarMode>,
-    #[serde(rename = "barnorm")]
-    bar_norm: Option<BarNorm>,
-    #[serde(rename = "bargap")]
-    bar_gap: Option<f64>,
-    #[serde(rename = "bargroupgap")]
-    bar_group_gap: Option<f64>,
-
-    #[serde(rename = "violinmode")]
-    violin_mode: Option<ViolinMode>,
-    #[serde(rename = "violingap")]
-    violin_gap: Option<f64>,
-    #[serde(rename = "violingroupgap")]
-    violin_group_gap: Option<f64>,
-
-    #[serde(rename = "waterfallmode")]
-    waterfall_mode: Option<WaterfallMode>,
-    #[serde(rename = "waterfallgap")]
-    waterfall_gap: Option<f64>,
-    #[serde(rename = "waterfallgroupgap")]
-    waterfall_group_gap: Option<f64>,
-
-    #[serde(rename = "piecolorway")]
-    pie_colorway: Option<Vec<Box<dyn Color>>>,
-    #[serde(rename = "extendpiecolors")]
-    extend_pie_colors: Option<bool>,
-
-    #[serde(rename = "sunburstcolorway")]
-    sunburst_colorway: Option<Vec<Box<dyn Color>>>,
-    #[serde(rename = "extendsunburstcolors")]
-    extend_sunburst_colors: Option<bool>,
-
-    mapbox: Option<Mapbox>,
-
-    #[serde(rename = "updatemenus")]
-    update_menus: Option<Vec<UpdateMenu>>,
-}
-
-impl LayoutTemplate {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn add_annotation(&mut self, annotation: Annotation) {
-        if self.annotations.is_none() {
-            self.annotations = Some(Vec::new());
-        }
-        self.annotations.as_mut().unwrap().push(annotation);
-    }
-
-    pub fn add_shape(&mut self, shape: Shape) {
-        if self.shapes.is_none() {
-            self.shapes = Some(Vec::new());
-        }
-        self.shapes.as_mut().unwrap().push(shape);
-    }
-}
-
-#[serde_with::skip_serializing_none]
-#[derive(Serialize, Debug, Clone, FieldSetter)]
-#[field_setter(kind = "layout")]
-pub struct Layout {
+/// Generates Layout and LayoutTemplate
+/// LayoutTemplate matches Layout except it lacks a field for template
+/// See layout/layout.rs for the full field list and doc comments.
+/// Layout is identical to LayoutTemplate except it has a `template` field and
+/// #[field_setter(kind = "layout")] See layout/layout.rs for the full field
+/// list and doc comments.
+#[layout_structs]
+pub struct LayoutFields {
     title: Option<Title>,
     #[serde(rename = "showlegend")]
     show_legend: Option<bool>,
@@ -411,54 +224,44 @@ pub struct Layout {
     spike_distance: Option<i32>,
     #[serde(rename = "hoverlabel")]
     hover_label: Option<Label>,
-    #[field_setter(skip)]
-    template: Option<Box<Cow<'static, Template>>>,
-
     grid: Option<LayoutGrid>,
     calendar: Option<Calendar>,
-
     #[serde(rename = "xaxis")]
     x_axis: Option<Box<Axis>>,
     #[serde(rename = "yaxis")]
     y_axis: Option<Box<Axis>>,
     #[serde(rename = "zaxis")]
     z_axis: Option<Box<Axis>>,
-
     #[serde(rename = "xaxis2")]
     x_axis2: Option<Box<Axis>>,
     #[serde(rename = "yaxis2")]
     y_axis2: Option<Box<Axis>>,
     #[serde(rename = "zaxis2")]
     z_axis2: Option<Box<Axis>>,
-
     #[serde(rename = "xaxis3")]
     x_axis3: Option<Box<Axis>>,
     #[serde(rename = "yaxis3")]
     y_axis3: Option<Box<Axis>>,
     #[serde(rename = "zaxis3")]
     z_axis3: Option<Box<Axis>>,
-
     #[serde(rename = "xaxis4")]
     x_axis4: Option<Box<Axis>>,
     #[serde(rename = "yaxis4")]
     y_axis4: Option<Box<Axis>>,
     #[serde(rename = "zaxis4")]
     z_axis4: Option<Box<Axis>>,
-
     #[serde(rename = "xaxis5")]
     x_axis5: Option<Box<Axis>>,
     #[serde(rename = "yaxis5")]
     y_axis5: Option<Box<Axis>>,
     #[serde(rename = "zaxis5")]
     z_axis5: Option<Box<Axis>>,
-
     #[serde(rename = "xaxis6")]
     x_axis6: Option<Box<Axis>>,
     #[serde(rename = "yaxis6")]
     y_axis6: Option<Box<Axis>>,
     #[serde(rename = "zaxis6")]
     z_axis6: Option<Box<Axis>>,
-
     #[serde(rename = "xaxis7")]
     x_axis7: Option<Box<Axis>>,
     #[serde(rename = "yaxis7")]
@@ -466,30 +269,24 @@ pub struct Layout {
     #[serde(rename = "zaxis7")]
     z_axis7: Option<Box<Axis>>,
     #[serde(rename = "xaxis8")]
-
     x_axis8: Option<Box<Axis>>,
     #[serde(rename = "yaxis8")]
     y_axis8: Option<Box<Axis>>,
     #[serde(rename = "zaxis8")]
     z_axis8: Option<Box<Axis>>,
-
-    // ternary: Option<LayoutTernary>,
     scene: Option<LayoutScene>,
-    // polar: Option<LayoutPolar>,
     annotations: Option<Vec<Annotation>>,
     shapes: Option<Vec<Shape>>,
     #[serde(rename = "newshape")]
     new_shape: Option<NewShape>,
     #[serde(rename = "activeshape")]
     active_shape: Option<ActiveShape>,
-
     #[serde(rename = "boxmode")]
     box_mode: Option<BoxMode>,
     #[serde(rename = "boxgap")]
     box_gap: Option<f64>,
     #[serde(rename = "boxgroupgap")]
     box_group_gap: Option<f64>,
-
     #[serde(rename = "barmode")]
     bar_mode: Option<BarMode>,
     #[serde(rename = "barnorm")]
@@ -498,69 +295,31 @@ pub struct Layout {
     bar_gap: Option<f64>,
     #[serde(rename = "bargroupgap")]
     bar_group_gap: Option<f64>,
-
     #[serde(rename = "violinmode")]
     violin_mode: Option<ViolinMode>,
     #[serde(rename = "violingap")]
     violin_gap: Option<f64>,
     #[serde(rename = "violingroupgap")]
     violin_group_gap: Option<f64>,
-
     #[serde(rename = "waterfallmode")]
     waterfall_mode: Option<WaterfallMode>,
     #[serde(rename = "waterfallgap")]
     waterfall_gap: Option<f64>,
     #[serde(rename = "waterfallgroupgap")]
     waterfall_group_gap: Option<f64>,
-
     #[serde(rename = "piecolorway")]
     pie_colorway: Option<Vec<Box<dyn Color>>>,
     #[serde(rename = "extendpiecolors")]
     extend_pie_colors: Option<bool>,
-
     #[serde(rename = "sunburstcolorway")]
     sunburst_colorway: Option<Vec<Box<dyn Color>>>,
     #[serde(rename = "extendsunburstcolors")]
     extend_sunburst_colors: Option<bool>,
-
     mapbox: Option<Mapbox>,
-
     #[serde(rename = "updatemenus")]
     update_menus: Option<Vec<UpdateMenu>>,
 }
 
-impl Layout {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn to_json(&self) -> String {
-        serde_json::to_string(self).unwrap()
-    }
-
-    pub fn add_annotation(&mut self, annotation: Annotation) {
-        if self.annotations.is_none() {
-            self.annotations = Some(Vec::new());
-        }
-        self.annotations.as_mut().unwrap().push(annotation);
-    }
-
-    pub fn add_shape(&mut self, shape: Shape) {
-        if self.shapes.is_none() {
-            self.shapes = Some(Vec::new());
-        }
-        self.shapes.as_mut().unwrap().push(shape);
-    }
-
-    pub fn template<T>(mut self, template: T) -> Layout
-    where
-        T: Into<Cow<'static, Template>>,
-    {
-        self.template = Some(Box::new(template.into()));
-        self
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use serde_json::{json, to_value};
diff --git a/plotly/src/layout/modes.rs b/plotly/src/layout/modes.rs
index 8de9de13..6c15f65c 100644
--- a/plotly/src/layout/modes.rs
+++ b/plotly/src/layout/modes.rs
@@ -1,5 +1,27 @@
 use serde::{Serialize, Serializer};
 
+#[derive(Serialize, Debug, Clone)]
+/// If "cube", this scene's axes are drawn as a cube, regardless of the axes'
+/// ranges. If "data", this scene's axes are drawn in proportion with the axes'
+/// ranges. If "manual", this scene's axes are drawn in proportion with the
+/// input of "aspectratio" (the default behavior if "aspectratio" is provided).
+/// If "auto", this scene's axes are drawn using the results of "data" except
+/// when one axis is more than four times the size of the two others, where in
+/// that case the results of "cube" are used.
+/// Default: "auto"
+#[derive(Default)]
+pub enum AspectMode {
+    #[serde(rename = "auto")]
+    #[default]
+    Auto,
+    #[serde(rename = "cube")]
+    Cube,
+    #[serde(rename = "data")]
+    Data,
+    #[serde(rename = "manual")]
+    Manual,
+}
+
 #[derive(Serialize, Debug, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum BoxMode {
@@ -123,4 +145,19 @@ mod tests {
         assert_eq!(to_value(WaterfallMode::Group).unwrap(), json!("group"));
         assert_eq!(to_value(WaterfallMode::Overlay).unwrap(), json!("overlay"));
     }
+
+    #[test]
+    fn serialize_aspect_mode() {
+        let aspect_mode = AspectMode::default();
+
+        assert_eq!(to_value(aspect_mode).unwrap(), json!("auto"));
+
+        let aspect_mode = AspectMode::Data;
+
+        assert_eq!(to_value(aspect_mode).unwrap(), json!("data"));
+
+        let aspect_mode = AspectMode::Cube;
+
+        assert_eq!(to_value(aspect_mode).unwrap(), json!("cube"));
+    }
 }
diff --git a/plotly/src/layout/scene.rs b/plotly/src/layout/scene.rs
index 523bcb4c..f1737008 100644
--- a/plotly/src/layout/scene.rs
+++ b/plotly/src/layout/scene.rs
@@ -2,29 +2,7 @@ use plotly_derive::FieldSetter;
 use serde::Serialize;
 
 use crate::color::Color;
-use crate::layout::{Annotation, Axis};
-
-#[derive(Serialize, Debug, Clone)]
-/// If "cube", this scene's axes are drawn as a cube, regardless of the axes'
-/// ranges. If "data", this scene's axes are drawn in proportion with the axes'
-/// ranges. If "manual", this scene's axes are drawn in proportion with the
-/// input of "aspectratio" (the default behavior if "aspectratio" is provided).
-/// If "auto", this scene's axes are drawn using the results of "data" except
-/// when one axis is more than four times the size of the two others, where in
-/// that case the results of "cube" are used.
-/// Default: "auto"
-#[derive(Default)]
-pub enum AspectMode {
-    #[serde(rename = "auto")]
-    #[default]
-    Auto,
-    #[serde(rename = "cube")]
-    Cube,
-    #[serde(rename = "data")]
-    Data,
-    #[serde(rename = "manual")]
-    Manual,
-}
+use crate::layout::{Annotation, AspectMode, Axis};
 
 #[serde_with::skip_serializing_none]
 #[derive(Serialize, Debug, Clone, FieldSetter)]
@@ -494,21 +472,6 @@ mod tests {
         assert_eq!(to_value(camera_center).unwrap(), expected);
     }
 
-    #[test]
-    fn serialize_aspect_mode() {
-        let aspect_mode = AspectMode::default();
-
-        assert_eq!(to_value(aspect_mode).unwrap(), json!("auto"));
-
-        let aspect_mode = AspectMode::Data;
-
-        assert_eq!(to_value(aspect_mode).unwrap(), json!("data"));
-
-        let aspect_mode = AspectMode::Cube;
-
-        assert_eq!(to_value(aspect_mode).unwrap(), json!("cube"));
-    }
-
     #[test]
     fn serialize_up() {
         let up = Up::new();
diff --git a/plotly_derive/src/lib.rs b/plotly_derive/src/lib.rs
index 6a74026b..e5111a73 100644
--- a/plotly_derive/src/lib.rs
+++ b/plotly_derive/src/lib.rs
@@ -1,7 +1,10 @@
 #![recursion_limit = "256"]
 
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::parse::Parser;
 use syn::DeriveInput;
-
+use syn::{parse_macro_input, ItemStruct};
 mod field_setter;
 
 #[proc_macro_derive(FieldSetter, attributes(field_setter))]
@@ -9,3 +12,85 @@ pub fn field_setter(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = syn::parse::<DeriveInput>(input).unwrap();
     field_setter::field_setter_impl(input)
 }
+
+#[proc_macro_attribute]
+pub fn layout_structs(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemStruct);
+    let vis = &input.vis;
+    let fields = &input.fields;
+    let attrs = &input.attrs;
+
+    // Generate LayoutTemplate (no template field, no #[field_setter(kind =
+    // "layout")])
+    let template_struct_name = format_ident!("LayoutTemplate");
+    let template_struct = quote! {
+        #(#attrs)*
+        #[serde_with::skip_serializing_none]
+        #[derive(Serialize, Debug, Clone, FieldSetter)]
+        #vis struct #template_struct_name #fields
+    };
+
+    // Generate Layout (with template field and #[field_setter(kind = "layout")])
+    let layout_struct_name = format_ident!("Layout");
+    let mut layout_fields = fields.clone();
+    // Add the template field
+    if let syn::Fields::Named(ref mut named) = layout_fields {
+        named.named.push(
+            syn::Field::parse_named
+                .parse2(quote! {
+                    #[field_setter(skip)]
+                    template: Option<Box<std::borrow::Cow<'static, Template>>>
+                })
+                .unwrap(),
+        );
+    }
+    let layout_struct = quote! {
+        #(#attrs)*
+        #[serde_with::skip_serializing_none]
+        #[derive(Serialize, Debug, Clone, FieldSetter)]
+        #[field_setter(kind = "layout")]
+        #vis struct #layout_struct_name #layout_fields
+    };
+
+    // Generate impls (add your methods as needed)
+    let template_impl = quote! {
+        impl #template_struct_name {
+            pub fn new() -> Self { Default::default() }
+            pub fn add_annotation(&mut self, annotation: Annotation) {
+                if self.annotations.is_none() { self.annotations = Some(Vec::new()); }
+                self.annotations.as_mut().unwrap().push(annotation);
+            }
+            pub fn add_shape(&mut self, shape: Shape) {
+                if self.shapes.is_none() { self.shapes = Some(Vec::new()); }
+                self.shapes.as_mut().unwrap().push(shape);
+            }
+        }
+    };
+    let layout_impl = quote! {
+        impl #layout_struct_name {
+            pub fn new() -> Self { Default::default() }
+            pub fn to_json(&self) -> String { serde_json::to_string(self).unwrap() }
+            pub fn add_annotation(&mut self, annotation: Annotation) {
+                if self.annotations.is_none() { self.annotations = Some(Vec::new()); }
+                self.annotations.as_mut().unwrap().push(annotation);
+            }
+            pub fn add_shape(&mut self, shape: Shape) {
+                if self.shapes.is_none() { self.shapes = Some(Vec::new()); }
+                self.shapes.as_mut().unwrap().push(shape);
+            }
+            pub fn template<T>(mut self, template: T) -> Self
+            where T: Into<std::borrow::Cow<'static, Template>> {
+                self.template = Some(Box::new(template.into()));
+                self
+            }
+        }
+    };
+
+    let expanded = quote! {
+        #template_struct
+        #layout_struct
+        #template_impl
+        #layout_impl
+    };
+    TokenStream::from(expanded)
+}