kittycad_modeling_cmds/

shared.rs

use bon::Builder;
use enum_iterator::Sequence;
use parse_display_derive::{Display, FromStr};
pub use point::{Point2d, Point3d, Point4d, Quaternion};
use schemars::{schema::SchemaObject, JsonSchema};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[cfg(feature = "cxx")]
use crate::impl_extern_type;
use crate::{
    def_enum::negative_one,
    id::ModelingCmdId,
    length_unit::LengthUnit,
    output::ExtrusionFaceInfo,
    units::{self, UnitAngle},
};

mod point;
pub mod safe_filepath;

/// An edge can be referenced by its uuid or by the faces that uniquely define it.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct EdgeSpecifier {
    /// Side face ids that uniquely identify the edge.
    pub side_faces: Vec<Uuid>,
    /// Optional end face ids for ambiguous edge matches.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    #[builder(default)]
    pub end_faces: Vec<Uuid>,
    /// Optional index for disambiguation when multiple edges share the same faces.
    /// If not provided (None), all matching edges will be used.
    /// If provided (Some(n)), only the edge at index n will be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub index: Option<u32>,
}

/// Optional fallback when primary UUIDs are missing from the client artifact graph (e.g. stale or
/// engine-only ids). Identifies the same topology via a **parent** entity UUID and a **primitive
/// index** on that parent.
///
/// Semantics by selection kind (aligned with engine BREP topology):
///
/// - **Face / Edge (3D)**: `parent_id` is the owning [`EntityType::Solid3D`] body UUID; `primitive_index`
///   matches the index returned by **EntityGetPrimitiveIndex** for that face or edge (and matches
///   **EntityGetParentId** → parent + **EntityGetPrimitiveIndex** → index).
/// - **Vertex (3D)**: same `parent_id` (solid); `primitive_index` is the BREP vertex index on that solid.
/// - **Solid2dEdge**: `parent_id` is the **Solid2D** profile UUID; `primitive_index` is the curve index
///   within that profile.
/// - **Segment**: `parent_id` is the **Path** UUID; `primitive_index` is the curve index within that path.
///
/// Other [`EntityReference`] variants may omit this field or leave it unset when not applicable.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct PrimitiveTopologyFallback {
    /// UUID of the parent entity that owns the primitive (solid3d, solid2d, or path).
    pub parent_id: Uuid,
    /// Index of the face, edge, vertex, profile curve, or path segment on `parent_id`.
    pub primitive_index: u32,
}

/// An edge/vertex can be defined by the faces that it is connected to.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(tag = "type", rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
pub enum EntityReference {
    /// A uuid referencing a plane.
    Plane {
        /// Id of the plane being referenced.
        plane_id: Uuid,
        /// Optional primitive topology on a parent (not used for planes today).
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
    /// A uuid referencing a face.
    Face {
        /// Id of the face being referenced.
        face_id: Uuid,
        /// Fallback: solid3d UUID + face index on that body when `face_id` cannot be resolved client-side.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
    /// A collection of ids that uniquely identify an edge.
    Edge {
        /// Flattened edge reference (side_faces, end_faces, index).
        #[serde(flatten)]
        inner: EdgeSpecifier,
        /// Fallback: solid3d UUID + edge index on that body for 3D BREP edges (distinct from `inner.index`).
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
    /// A collection of ids that uniquely identify an vertex.
    Vertex {
        /// Side face ids that identify the vertex.
        side_faces: Vec<Uuid>,
        /// Optional index among the filtered candidates.
        #[serde(skip_serializing_if = "Option::is_none")]
        index: Option<u32>,
        /// Fallback: solid3d UUID + vertex index on that body.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
    /// A uuid referencing a solid2d (profile).
    Solid2d {
        /// Id of the solid2d being referenced.
        solid2d_id: Uuid,
        /// Typically omitted: `solid2d_id` is already the owning profile. Present for schema parity with other variants.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
    /// A uuid referencing a solid3d (body).
    Solid3d {
        /// Id of the solid3d being referenced.
        solid3d_id: Uuid,
        /// Typically omitted: `solid3d_id` is already the owning body. Present for schema parity with other variants.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
    /// A uuid referencing an edge on a solid2d (profile) - used for raw sketch/profile edges.
    /// This is distinct from the face-based Edge reference which is used for BRep/swept body edges.
    Solid2dEdge {
        /// Id of the edge being referenced.
        edge_id: Uuid,
        /// Fallback: solid2d UUID + curve index in that profile.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
    /// A single segment (curve) within a path.
    Segment {
        /// Id of the path containing the segment.
        path_id: Uuid,
        /// Id of the segment (curve) being referenced.
        segment_id: Uuid,
        /// Fallback: path UUID + segment curve index.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
    /// A closed sketch region/profile area.
    Region {
        /// Id of the region being referenced.
        region_id: Uuid,
        /// Fallback: path UUID + region index on that path.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        topology_fallback: Option<PrimitiveTopologyFallback>,
    },
}

/// What kind of cut to do
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema, Default)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
pub enum CutType {
    /// Round off an edge.
    #[default]
    Fillet,
    /// Cut away an edge.
    Chamfer,
}

/// What to use as a direction when one is needed (e.g. for an extrusion).
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
pub enum DirectionType {
    /// Uses the direction of an edge, if linear
    Edge {
        /// Edge ID.
        id: Uuid,
    },
    /// Uses the provided vector as the direction.
    Axis {
        /// Direction.
        direction: Point3d<f64>,
    },
}

/// What to reflect mirrored geometry across
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
pub enum MirrorAcross {
    /// Reflect across an edge
    /// If used with a 3D mirror, the edge will define the normal of the mirror plane.
    Edge {
        /// Edge ID.
        id: Uuid,
    },
    /// Reflect across an edge identified by its adjacent faces.
    /// If used with a 3D mirror, the edge will define the normal of the mirror plane.
    EdgeReference {
        /// Stable edge reference.
        reference: EdgeSpecifier,
    },
    /// Reflect across an axis (that goes through a point)
    /// If used with a 3D mirror, the axis will define the normal of the mirror plane.
    Axis {
        /// Axis to use as mirror.
        axis: Point3d<f64>,
        /// Point through which the mirror axis passes.
        point: Point3d<LengthUnit>,
    },
    /// Reflect across a plane (which gives two axes)
    /// Cannot be used with 2D mirrors.
    Plane {
        /// Plane ID.
        id: Uuid,
    },
}

/// What kind of cut to perform when cutting an edge.
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum CutTypeV2 {
    /// Round off an edge.
    Fillet {
        /// The radius of the fillet.
        radius: LengthUnit,
        /// The second length affects the edge length of the second face of the cut. This will
        /// cause the fillet to take on the shape of a conic section, instead of an arc.
        second_length: Option<LengthUnit>,
    },
    /// Cut away an edge.
    Chamfer {
        /// The distance from the edge to cut on each face.
        distance: LengthUnit,
        /// The second distance affects the edge length of the second face of the cut.
        second_distance: Option<LengthUnit>,
        /// The angle of the chamfer, default is 45deg.
        angle: Option<Angle>,
        /// If true, the second distance or angle is applied to the other face of the cut.
        swap: bool,
    },
    /// A custom cut profile.
    Custom {
        /// The path that will be used for the custom profile.
        path: Uuid,
    },
}

/// A rotation defined by an axis, origin of rotation, and an angle.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct Rotation {
    /// Rotation axis.
    /// Defaults to (0, 0, 1) (i.e. the Z axis).
    pub axis: Point3d<f64>,
    /// Rotate this far about the rotation axis.
    /// Defaults to zero (i.e. no rotation).
    pub angle: Angle,
    /// Origin of the rotation. If one isn't provided, the object will rotate about its own bounding box center.
    pub origin: OriginType,
}

impl Default for Rotation {
    /// z-axis, 0 degree angle, and local origin.
    fn default() -> Self {
        Self {
            axis: z_axis(),
            angle: Angle::default(),
            origin: OriginType::Local,
        }
    }
}

/// Ways to transform each solid being replicated in a repeating pattern.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct Transform {
    /// Translate the replica this far along each dimension.
    /// Defaults to zero vector (i.e. same position as the original).
    #[serde(default)]
    #[builder(default)]
    pub translate: Point3d<LengthUnit>,
    /// Scale the replica's size along each axis.
    /// Defaults to (1, 1, 1) (i.e. the same size as the original).
    #[serde(default = "same_scale")]
    #[builder(default = same_scale())]
    pub scale: Point3d<f64>,
    /// Rotate the replica about the specified rotation axis and origin.
    /// Defaults to no rotation.
    #[serde(default)]
    #[builder(default)]
    pub rotation: Rotation,
    /// Whether to replicate the original solid in this instance.
    #[serde(default = "bool_true")]
    #[builder(default = bool_true())]
    pub replicate: bool,
}

impl Default for Transform {
    fn default() -> Self {
        Self {
            scale: same_scale(),
            replicate: true,
            translate: Default::default(),
            rotation: Rotation::default(),
        }
    }
}

/// Options for annotations
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct AnnotationOptions {
    /// Text displayed on the annotation
    pub text: Option<AnnotationTextOptions>,
    /// How to style the start and end of the line
    pub line_ends: Option<AnnotationLineEndOptions>,
    /// Width of the annotation's line
    pub line_width: Option<f32>,
    /// Color to render the annotation
    pub color: Option<Color>,
    /// Position to put the annotation
    pub position: Option<Point3d<f32>>,
    /// Length Units to use for this individual annotation.  If not provided, the units set by SetSceneUnits will be used.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub units: Option<units::UnitLength>,
    /// Set as an MBD measured basic dimension annotation
    pub dimension: Option<AnnotationBasicDimension>,
    /// Set as an MBD Feature control annotation
    pub feature_control: Option<AnnotationFeatureControl>,
    /// Set as a feature tag annotation
    pub feature_tag: Option<AnnotationFeatureTag>,
}

/// Options for annotation text
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct AnnotationLineEndOptions {
    /// How to style the start of the annotation line.
    pub start: AnnotationLineEnd,
    /// How to style the end of the annotation line.
    pub end: AnnotationLineEnd,
}

/// Options for annotation text
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct AnnotationTextOptions {
    /// Alignment along the X axis
    pub x: AnnotationTextAlignmentX,
    /// Alignment along the Y axis
    pub y: AnnotationTextAlignmentY,
    /// Text displayed on the annotation
    pub text: String,
    /// Text font's point size
    pub point_size: u32,
}

/// Parameters for defining an MBD Geometric control frame
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct AnnotationMbdControlFrame {
    ///Geometric symbol, the type of geometric control specified
    pub symbol: MbdSymbol,
    /// Diameter symbol (if required) whether the geometric control requires a cylindrical or diameter tolerance
    pub diameter_symbol: Option<MbdSymbol>,
    /// Tolerance value - the total tolerance of the geometric control.  The unit is based on the drawing standard.
    pub tolerance: f64,
    /// Feature of size or tolerance modifiers
    pub modifier: Option<MbdSymbol>,
    /// Primary datum
    pub primary_datum: Option<char>,
    /// Secondary datum
    pub secondary_datum: Option<char>,
    /// Tertiary datum
    pub tertiary_datum: Option<char>,
}

/// Parameters for defining an MBD basic dimension
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct AnnotationMbdBasicDimension {
    /// Type of symbol to use for this dimension (if required)
    pub symbol: Option<MbdSymbol>,
    /// The explicitly defined dimension.  Only required if the measurement is not automatically calculated.
    pub dimension: Option<f64>,
    /// The tolerance of the dimension
    pub tolerance: f64,
}

/// Parameters for defining an MBD Basic Dimension Annotation state which is measured between two positions in 3D
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct AnnotationBasicDimension {
    /// Entity to measure the dimension from
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from_entity_id: Option<Uuid>,

    /// Edge reference to use to measure the dimension from
    /// If both `from_entity_id` and `from_edge_reference` are provided, `from_edge_reference` takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from_edge_reference: Option<EdgeSpecifier>,

    /// Normalized position within the entity to position the dimension from
    pub from_entity_pos: Point2d<f64>,

    /// Entity to measure the dimension to
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub to_entity_id: Option<Uuid>,

    /// Edge reference to use to measure the dimension from
    /// If both `to_entity_id` and `to_edge_reference` are provided, `to_edge_reference` takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub to_edge_reference: Option<EdgeSpecifier>,

    /// Normalized position within the entity to position the dimension to
    pub to_entity_pos: Point2d<f64>,

    /// Basic dimension parameters (symbol and tolerance)
    pub dimension: AnnotationMbdBasicDimension,

    /// Orientation plane.  The annotation will lie in this plane which is positioned about the leader position as its origin.
    pub plane_id: Uuid,

    /// 2D Position offset of the annotation within the plane.
    pub offset: Point2d<f64>,

    /// Number of decimal places to use when displaying tolerance and dimension values
    pub precision: u32,

    /// The scale of the font label in 3D space
    pub font_scale: f32,

    /// The point size of the fonts used to generate the annotation label.  Very large values can negatively affect performance.
    pub font_point_size: u32,

    /// The scale of the dimension arrows. Defaults to 1.
    #[serde(default = "one")]
    pub arrow_scale: f32,
}

/// Parameters for defining an MBD Feature Control Annotation state
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct AnnotationFeatureControl {
    /// Entity to place the annotation leader from
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entity_id: Option<Uuid>,

    /// Edge reference to use to place the annotation leader from
    /// If both `entity_id` and `edge_reference` are provided, `edge_reference` takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edge_reference: Option<EdgeSpecifier>,

    /// Normalized position within the entity to position the annotation leader from
    pub entity_pos: Point2d<f64>,

    /// Type of leader to use
    pub leader_type: AnnotationLineEnd,

    /// Basic dimensions
    pub dimension: Option<AnnotationMbdBasicDimension>,

    /// MBD Control frame for geometric control
    pub control_frame: Option<AnnotationMbdControlFrame>,

    /// Set if this annotation is defining a datum
    pub defined_datum: Option<char>,

    /// Prefix text which will appear before the basic dimension
    pub prefix: Option<String>,

    /// Suffix text which will appear after the basic dimension
    pub suffix: Option<String>,

    /// Orientation plane.  The annotation will lie in this plane which is positioned about the leader position as its origin.
    pub plane_id: Uuid,

    /// 2D Position offset of the annotation within the plane.
    pub offset: Point2d<f64>,

    /// Number of decimal places to use when displaying tolerance and dimension values
    pub precision: u32,

    /// The scale of the font label in 3D space
    pub font_scale: f32,

    /// The point size of the fonts used to generate the annotation label.  Very large values can negatively affect performance.
    pub font_point_size: u32,

    /// The scale of the leader (dot or arrow). Defaults to 1.
    #[serde(default = "one")]
    pub leader_scale: f32,
}

/// Parameters for defining an MBD Feature Tag Annotation state
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct AnnotationFeatureTag {
    /// Entity to place the annotation leader from
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entity_id: Option<Uuid>,

    /// Edge reference to use to place the annotation leader from
    /// If both `entity_id` and `edge_reference` are provided, `edge_reference` takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edge_reference: Option<EdgeSpecifier>,

    /// Normalized position within the entity to position the annotation leader from
    pub entity_pos: Point2d<f64>,

    /// Type of leader to use
    pub leader_type: AnnotationLineEnd,

    /// Tag key
    pub key: String,

    /// Tag value
    pub value: String,

    /// Whether or not to display the key on the annotation label
    pub show_key: bool,

    /// Orientation plane.  The annotation will lie in this plane which is positioned about the leader position as its origin.
    pub plane_id: Uuid,

    /// 2D Position offset of the annotation within the plane.
    pub offset: Point2d<f64>,

    /// The scale of the font label in 3D space
    pub font_scale: f32,

    /// The point size of the fonts used to generate the annotation label.  Very large values can negatively affect performance.
    pub font_point_size: u32,

    /// The scale of the leader (dot or arrow). Defaults to 1.
    #[serde(default = "one")]
    pub leader_scale: f32,
}

/// The type of distance
/// Distances can vary depending on
/// the objects used as input.
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case", tag = "type")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum DistanceType {
    /// Euclidean Distance.
    Euclidean {},
    /// The distance between objects along the specified axis
    OnAxis {
        /// Global axis
        axis: GlobalAxis,
    },
}

/// The type of origin
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema, Default)]
#[serde(rename_all = "snake_case", tag = "type")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum OriginType {
    /// Local Origin ([0, 0, 0] in object space).
    #[default]
    Local,
    /// Global Origin ([0, 0, 0] in world space).
    Global,
    /// Custom Origin (user specified point in world space).
    Custom {
        /// Custom origin point.
        origin: Point3d<f64>,
    },
}

/// An RGBA color
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct Color {
    /// Red
    pub r: f32,
    /// Green
    pub g: f32,
    /// Blue
    pub b: f32,
    /// Alpha
    pub a: f32,
}

impl Color {
    /// Assign the red, green, blue and alpha (transparency) channels.
    pub fn from_rgba(r: f32, g: f32, b: f32, a: f32) -> Self {
        Self { r, g, b, a }
    }
}

/// Horizontal Text alignment
#[allow(missing_docs)]
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum AnnotationTextAlignmentX {
    Left,
    Center,
    Right,
}

/// Vertical Text alignment
#[allow(missing_docs)]
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum AnnotationTextAlignmentY {
    Bottom,
    Center,
    Top,
}

/// Annotation line end type
#[allow(missing_docs)]
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum AnnotationLineEnd {
    None,
    Arrow,
    Dot,
}

/// The type of annotation
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum AnnotationType {
    /// 2D annotation type (screen or planar space)
    T2D,
    /// 3D annotation type
    T3D,
}

/// MBD standard
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum MbdStandard {
    /// ASME Y14.5 GD&T
    AsmeY14_5,
}

//SEE MIKE BEFORE MAKING ANY CHANGES TO THIS ENUM
/// MBD symbol type
#[allow(missing_docs)]
#[derive(
    Default,
    Display,
    FromStr,
    Copy,
    Eq,
    PartialEq,
    Debug,
    JsonSchema,
    Deserialize,
    Serialize,
    Sequence,
    Clone,
    Ord,
    PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[repr(u16)]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum MbdSymbol {
    #[default]
    None = 0,
    ArcLength = 174,
    Between = 175,
    Degrees = 176,
    PlusMinus = 177,
    Angularity = 178,
    Cylindricity = 179,
    Roundness = 180,
    Concentricity = 181,
    Straightness = 182,
    Parallelism = 183,
    Flatness = 184,
    ProfileOfLine = 185,
    SurfaceProfile = 186,
    Symmetry = 187,
    Perpendicularity = 188,
    Runout = 189,
    TotalRunout = 190,
    Position = 191,
    CenterLine = 192,
    PartingLine = 193,
    IsoEnvelope = 195,
    IsoEnvelopeNonY145M = 196,
    FreeState = 197,
    StatisticalTolerance = 198,
    ContinuousFeature = 199,
    Independency = 200,
    Depth = 201,
    Start = 202,
    LeastCondition = 203,
    MaxCondition = 204,
    ConicalTaper = 205,
    Projected = 206,
    Slope = 207,
    Micro = 208,
    TangentPlane = 210,
    Unilateral = 211,
    SquareFeature = 212,
    Countersink = 213,
    SpotFace = 214,
    Target = 215,
    Diameter = 216,
    Radius = 217,
    SphericalRadius = 218,
    SphericalDiameter = 219,
    ControlledRadius = 220,
    BoxStart = 123,
    BoxBar = 162,
    BoxBarBetween = 124,
    LetterBackwardUnderline = 95,
    PunctuationBackwardUnderline = 92,
    ModifierBackwardUnderline = 126,
    NumericBackwardUnderline = 96,
    BoxEnd = 125,
    DatumUp = 166,
    DatumLeft = 168,
    DatumRight = 167,
    DatumDown = 165,
    DatumTriangle = 295,
    HalfSpace = 236,
    QuarterSpace = 237,
    EighthSpace = 238,
    ModifierSpace = 239,
}

/// The type of camera drag interaction.
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum CameraDragInteractionType {
    /// Camera pan
    Pan,
    /// Camera rotate (spherical camera revolve/orbit)
    Rotate,
    /// Camera rotate (trackball with 3 degrees of freedom)
    RotateTrackball,
    /// Camera zoom (increase or decrease distance to reference point center)
    Zoom,
}

/// A segment of a path.
/// Paths are composed of many segments.
#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq)]
#[serde(rename_all = "snake_case", tag = "type")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum PathSegment {
    /// A straight line segment.
    /// Goes from the current path "pen" to the given endpoint.
    Line {
        /// End point of the line.
        end: Point3d<LengthUnit>,
        ///Whether or not this line is a relative offset
        relative: bool,
    },
    /// A circular arc segment.
    /// Arcs can be drawn clockwise when start > end.
    Arc {
        /// Center of the circle
        center: Point2d<LengthUnit>,
        /// Radius of the circle
        radius: LengthUnit,
        /// Start of the arc along circle's perimeter.
        start: Angle,
        /// End of the arc along circle's perimeter.
        end: Angle,
        ///Whether or not this arc is a relative offset
        relative: bool,
    },
    /// A cubic bezier curve segment.
    /// Start at the end of the current line, go through control point 1 and 2, then end at a
    /// given point.
    Bezier {
        /// First control point.
        control1: Point3d<LengthUnit>,
        /// Second control point.
        control2: Point3d<LengthUnit>,
        /// Final control point.
        end: Point3d<LengthUnit>,
        ///Whether or not this bezier is a relative offset
        relative: bool,
    },
    /// Adds a tangent arc from current pen position with the given radius and angle.
    TangentialArc {
        /// Radius of the arc.
        /// Not to be confused with Raiders of the Lost Ark.
        radius: LengthUnit,
        /// Offset of the arc. Negative values will arc clockwise.
        offset: Angle,
    },
    /// Adds a tangent arc from current pen position to the new position.
    /// Arcs will choose a clockwise or counter-clockwise direction based on the arc end position.
    TangentialArcTo {
        /// Where the arc should end.
        /// Must lie in the same plane as the current path pen position.
        /// Must not be colinear with current path pen position.
        to: Point3d<LengthUnit>,
        /// 0 will be interpreted as none/null.
        angle_snap_increment: Option<Angle>,
    },
    ///Adds an arc from the current position that goes through the given interior point and ends at the given end position
    ArcTo {
        /// Interior point of the arc.
        interior: Point3d<LengthUnit>,
        /// End point of the arc.
        end: Point3d<LengthUnit>,
        ///Whether or not interior and end are relative to the previous path position
        relative: bool,
    },
    ///Adds a circular involute from the current position that goes through the given end_radius
    ///and is rotated around the current point by angle.
    CircularInvolute {
        ///The involute is described between two circles, start_radius is the radius of the inner
        ///circle.
        start_radius: LengthUnit,
        ///The involute is described between two circles, end_radius is the radius of the outer
        ///circle.
        end_radius: LengthUnit,
        ///The angle to rotate the involute by. A value of zero will produce a curve with a tangent
        ///along the x-axis at the start point of the curve.
        angle: Angle,
        ///If reverse is true, the segment will start
        ///from the end of the involute, otherwise it will start from that start.
        reverse: bool,
    },
    ///Adds an elliptical arc segment.
    Ellipse {
        /// The center point of the ellipse.
        center: Point2d<LengthUnit>,
        /// Major axis of the ellipse.
        major_axis: Point2d<LengthUnit>,
        /// Minor radius of the ellipse.
        minor_radius: LengthUnit,
        /// Start of the path along the perimeter of the ellipse.
        start_angle: Angle,
        /// End of the path along the perimeter of the ellipse.
        end_angle: Angle,
    },
    ///Adds a generic conic section specified by the end point, interior point and tangents at the
    ///start and end of the section.
    ConicTo {
        /// Interior point that lies on the conic.
        interior: Point2d<LengthUnit>,
        /// End point of the conic.
        end: Point2d<LengthUnit>,
        /// Tangent at the start of the conic.
        start_tangent: Point2d<LengthUnit>,
        /// Tangent at the end of the conic.
        end_tangent: Point2d<LengthUnit>,
        /// Whether or not the interior and end points are relative to the previous path position.
        relative: bool,
    },
}

/// An angle, with a specific unit.
#[derive(Clone, Copy, PartialEq, Debug, JsonSchema, Deserialize, Serialize)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct Angle {
    /// What unit is the measurement?
    pub unit: UnitAngle,
    /// The size of the angle, measured in the chosen unit.
    pub value: f64,
}

impl Angle {
    /// Converts a given angle to degrees.
    pub fn to_degrees(self) -> f64 {
        match self.unit {
            UnitAngle::Degrees => self.value,
            UnitAngle::Radians => self.value.to_degrees(),
        }
    }
    /// Converts a given angle to radians.
    pub fn to_radians(self) -> f64 {
        match self.unit {
            UnitAngle::Degrees => self.value.to_radians(),
            UnitAngle::Radians => self.value,
        }
    }
    /// Create an angle in degrees.
    pub const fn from_degrees(value: f64) -> Self {
        Self {
            unit: UnitAngle::Degrees,
            value,
        }
    }
    /// Create an angle in radians.
    pub const fn from_radians(value: f64) -> Self {
        Self {
            unit: UnitAngle::Radians,
            value,
        }
    }
    /// 360 degrees.
    pub const fn turn() -> Self {
        Self::from_degrees(360.0)
    }
    /// 180 degrees.
    pub const fn half_circle() -> Self {
        Self::from_degrees(180.0)
    }
    /// 90 degrees.
    pub const fn quarter_circle() -> Self {
        Self::from_degrees(90.0)
    }
    /// 0 degrees.
    pub const fn zero() -> Self {
        Self::from_degrees(0.0)
    }
}

/// 0 degrees.
impl Default for Angle {
    /// 0 degrees.
    fn default() -> Self {
        Self::zero()
    }
}

impl PartialOrd for Angle {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        match (self.unit, other.unit) {
            // Avoid unnecessary floating point operations.
            (UnitAngle::Degrees, UnitAngle::Degrees) => self.value.partial_cmp(&other.value),
            (UnitAngle::Radians, UnitAngle::Radians) => self.value.partial_cmp(&other.value),
            _ => self.to_degrees().partial_cmp(&other.to_degrees()),
        }
    }
}

impl std::ops::Add for Angle {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        Self {
            unit: UnitAngle::Degrees,
            value: self.to_degrees() + rhs.to_degrees(),
        }
    }
}

impl std::ops::AddAssign for Angle {
    fn add_assign(&mut self, rhs: Self) {
        match self.unit {
            UnitAngle::Degrees => {
                self.value += rhs.to_degrees();
            }
            UnitAngle::Radians => {
                self.value += rhs.to_radians();
            }
        }
    }
}

/// The type of scene selection change
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum SceneSelectionType {
    /// Replaces the selection
    Replace,
    /// Adds to the selection
    Add,
    /// Removes from the selection
    Remove,
}

/// The type of scene's active tool
#[allow(missing_docs)]
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum SceneToolType {
    CameraRevolve,
    Select,
    Move,
    SketchLine,
    SketchTangentialArc,
    SketchCurve,
    SketchCurveMod,
}

/// The path component constraint bounds type
#[allow(missing_docs)]
#[derive(
    Display,
    FromStr,
    Copy,
    Eq,
    PartialEq,
    Debug,
    JsonSchema,
    Deserialize,
    Serialize,
    Sequence,
    Clone,
    Ord,
    PartialOrd,
    Default,
)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum PathComponentConstraintBound {
    #[default]
    Unconstrained,
    PartiallyConstrained,
    FullyConstrained,
}

/// The path component constraint type
#[allow(missing_docs)]
#[derive(
    Display,
    FromStr,
    Copy,
    Eq,
    PartialEq,
    Debug,
    JsonSchema,
    Deserialize,
    Serialize,
    Sequence,
    Clone,
    Ord,
    PartialOrd,
    Default,
)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum PathComponentConstraintType {
    #[default]
    Unconstrained,
    Vertical,
    Horizontal,
    EqualLength,
    Parallel,
    AngleBetween,
}

/// The path component command type (within a Path)
#[allow(missing_docs)]
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum PathCommand {
    MoveTo,
    LineTo,
    BezCurveTo,
    NurbsCurveTo,
    AddArc,
}

/// The type of entity
#[allow(missing_docs)]
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[repr(u8)]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum EntityType {
    Entity,
    Object,
    Path,
    Segment,
    Curve,
    Solid2D,
    Solid3D,
    Edge,
    Face,
    Plane,
    Vertex,
    Region,
}

/// The type of Curve (embedded within path)
#[allow(missing_docs)]
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum CurveType {
    Line,
    Arc,
    Nurbs,
}

/// A file to be exported to the client.
#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone, PartialEq, Builder)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(from_py_object),
    pyo3_stub_gen::derive::gen_stub_pyclass
)]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct ExportFile {
    /// The name of the file.
    pub name: String,
    /// The contents of the file, base64 encoded.
    pub contents: crate::base64::Base64Data,
}

#[cfg(feature = "python")]
#[pyo3_stub_gen::derive::gen_stub_pymethods]
#[pyo3::pymethods]
impl ExportFile {
    #[getter]
    fn contents(&self) -> Vec<u8> {
        self.contents.0.clone()
    }

    #[getter]
    fn name(&self) -> String {
        self.name.clone()
    }
}

/// The valid types of output file formats.
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Clone, Ord, PartialOrd, Sequence,
)]
#[serde(rename_all = "lowercase")]
#[display(style = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(from_py_object),
    pyo3_stub_gen::derive::gen_stub_pyclass_enum
)]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum FileExportFormat {
    /// Autodesk Filmbox (FBX) format. <https://en.wikipedia.org/wiki/FBX>
    Fbx,
    /// Binary glTF 2.0.
    ///
    /// This is a single binary with .glb extension.
    ///
    /// This is better if you want a compressed format as opposed to the human readable
    /// glTF that lacks compression.
    Glb,
    /// glTF 2.0.
    /// Embedded glTF 2.0 (pretty printed).
    ///
    /// Single JSON file with .gltf extension binary data encoded as
    /// base64 data URIs.
    ///
    /// The JSON contents are pretty printed.
    ///
    /// It is human readable, single file, and you can view the
    /// diff easily in a git commit.
    Gltf,
    /// The OBJ file format. <https://en.wikipedia.org/wiki/Wavefront_.obj_file>
    /// It may or may not have an an attached material (mtl // mtllib) within the file,
    /// but we interact with it as if it does not.
    Obj,
    /// The PLY file format. <https://en.wikipedia.org/wiki/PLY_(file_format)>
    Ply,
    /// The STEP file format. <https://en.wikipedia.org/wiki/ISO_10303-21>
    Step,
    /// The STL file format. <https://en.wikipedia.org/wiki/STL_(file_format)>
    Stl,
}

/// The valid types of 2D output file formats.
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Clone, Ord, PartialOrd, Sequence,
)]
#[serde(rename_all = "lowercase")]
#[display(style = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum FileExportFormat2d {
    /// AutoCAD drawing interchange format.
    Dxf,
}

/// The valid types of source file formats.
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Clone, Ord, PartialOrd, Sequence,
)]
#[serde(rename_all = "lowercase")]
#[display(style = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum FileImportFormat {
    /// ACIS part format.
    Acis,
    /// CATIA part format.
    Catia,
    /// PTC Creo part format.
    Creo,
    /// Autodesk Filmbox (FBX) format. <https://en.wikipedia.org/wiki/FBX>
    Fbx,
    /// glTF 2.0.
    Gltf,
    /// Autodesk Inventor part format.
    Inventor,
    /// Siemens NX part format.
    Nx,
    /// The OBJ file format. <https://en.wikipedia.org/wiki/Wavefront_.obj_file>
    /// It may or may not have an an attached material (mtl // mtllib) within the file,
    /// but we interact with it as if it does not.
    Obj,
    /// Parasolid part format.
    Parasolid,
    /// The PLY file format. <https://en.wikipedia.org/wiki/PLY_(file_format)>
    Ply,
    /// SolidWorks part (SLDPRT) format.
    Sldprt,
    /// The STEP file format. <https://en.wikipedia.org/wiki/ISO_10303-21>
    Step,
    /// The STL file format. <https://en.wikipedia.org/wiki/STL_(file_format)>
    Stl,
}

/// The type of error sent by the KittyCAD graphics engine.
#[derive(Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Clone, Ord, PartialOrd)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum EngineErrorCode {
    /// User requested something geometrically or graphically impossible.
    /// Don't retry this request, as it's inherently impossible. Instead, read the error message
    /// and change your request.
    BadRequest = 1,
    /// Graphics engine failed to complete request, consider retrying
    InternalEngine,
}

impl From<EngineErrorCode> for http::StatusCode {
    fn from(e: EngineErrorCode) -> Self {
        match e {
            EngineErrorCode::BadRequest => Self::BAD_REQUEST,
            EngineErrorCode::InternalEngine => Self::INTERNAL_SERVER_ERROR,
        }
    }
}

/// What kind of blend to do
#[derive(Default, Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
pub enum BlendType {
    /// Use the tangent of the surfaces to calculate the blend.
    #[default]
    Tangent,
}

/// Body type determining if the operation will create a manifold (solid) body or a non-manifold collection of surfaces.
#[derive(Default, Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum BodyType {
    ///Defines a body that is manifold.
    #[default]
    Solid,
    ///Defines a body that is non-manifold (an open collection of connected surfaces).
    Surface,
}

/// Extrusion method determining if the extrusion will be part of the existing object or an
/// entirely new object.
#[derive(Default, Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum ExtrudeMethod {
    /// Create a new object that is not connected to the object it is extruded from. This will
    /// result in two objects after the operation.
    New,
    /// This extrusion will be part of object it is extruded from. This will result in one object
    /// after the operation.
    #[default]
    Merge,
}

/// Type of reference geometry to extrude to.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum ExtrudeReference {
    /// Extrudes along the normal of the top face until it is as close to the entity as possible.
    /// An entity can be a solid, a path, a face, an edge (via `entity_reference`), etc.
    EntityReference {
        /// Legacy UUID of the entity to extrude to. If both `entity_id` and `entity_reference` are provided, `entity_reference` takes precedence.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        entity_id: Option<Uuid>,
        /// Entity reference (e.g. edge by side_faces). If both `entity_id` and `entity_reference` are provided, `entity_reference` takes precedence.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        entity_reference: Option<EntityReference>,
    },
    /// Extrudes until the top face is as close as possible to this given axis.
    Axis {
        /// The axis to extrude to.
        axis: Point3d<f64>,
        /// Point the axis goes through.
        /// Defaults to (0, 0, 0).
        #[serde(default)]
        point: Point3d<LengthUnit>,
    },
    /// Extrudes until the top face is as close as possible to this given point.
    Point {
        /// The point to extrude to.
        point: Point3d<LengthUnit>,
    },
}

/// IDs for the extruded faces.
#[derive(Debug, PartialEq, Serialize, Deserialize, JsonSchema, Clone, Builder)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct ExtrudedFaceInfo {
    /// The face made from the original 2D shape being extruded.
    /// If the solid is extruded from a shape which already has an ID
    /// (e.g. extruding something which was sketched on a face), this
    /// doesn't need to be sent.
    pub bottom: Option<Uuid>,
    /// Top face of the extrusion (parallel and further away from the original 2D shape being extruded).
    pub top: Uuid,
    /// Any intermediate sides between the top and bottom.
    pub sides: Vec<SideFace>,
}

/// IDs for a side face, extruded from the path of some sketch/2D shape.
#[derive(Debug, PartialEq, Serialize, Deserialize, JsonSchema, Clone, Builder)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct SideFace {
    /// ID of the path this face is being extruded from.
    pub path_id: Uuid,
    /// Desired ID for the resulting face.
    pub face_id: Uuid,
}

/// Camera settings including position, center, fov etc
#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone, PartialEq, Builder)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct CameraSettings {
    ///Camera position (vantage)
    pub pos: Point3d,

    ///Camera's look-at center (center-pos gives viewing vector)
    pub center: Point3d,

    ///Camera's world-space up vector
    pub up: Point3d,

    ///The Camera's orientation (in the form of a quaternion)
    pub orientation: Quaternion,

    ///Camera's field-of-view angle (if ortho is false)
    pub fov_y: Option<f32>,

    ///The camera's ortho scale (derived from viewing distance if ortho is true)
    pub ortho_scale: Option<f32>,

    ///Whether or not the camera is in ortho mode
    pub ortho: bool,
}

#[allow(missing_docs)]
#[repr(u8)]
#[derive(Default, Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum WorldCoordinateSystem {
    #[default]
    RightHandedUpZ,
    RightHandedUpY,
}

#[allow(missing_docs)]
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct CameraViewState {
    pub pivot_rotation: Quaternion,
    pub pivot_position: Point3d,
    pub eye_offset: f32,
    pub fov_y: f32,
    pub ortho_scale_factor: f32,
    pub is_ortho: bool,
    pub ortho_scale_enabled: bool,
    pub world_coord_system: WorldCoordinateSystem,
}

impl Default for CameraViewState {
    fn default() -> Self {
        CameraViewState {
            pivot_rotation: Default::default(),
            pivot_position: Default::default(),
            eye_offset: 10.0,
            fov_y: 45.0,
            ortho_scale_factor: 1.6,
            is_ortho: false,
            ortho_scale_enabled: true,
            world_coord_system: Default::default(),
        }
    }
}

#[cfg(feature = "cxx")]
impl_extern_type! {
    [Trivial]
    CameraViewState = "Endpoints::CameraViewState"
}

impl From<CameraSettings> for crate::output::DefaultCameraZoom {
    fn from(settings: CameraSettings) -> Self {
        Self { settings }
    }
}
impl From<CameraSettings> for crate::output::CameraDragMove {
    fn from(settings: CameraSettings) -> Self {
        Self { settings }
    }
}
impl From<CameraSettings> for crate::output::CameraDragEnd {
    fn from(settings: CameraSettings) -> Self {
        Self { settings }
    }
}
impl From<CameraSettings> for crate::output::DefaultCameraGetSettings {
    fn from(settings: CameraSettings) -> Self {
        Self { settings }
    }
}
impl From<CameraSettings> for crate::output::ZoomToFit {
    fn from(settings: CameraSettings) -> Self {
        Self { settings }
    }
}
impl From<CameraSettings> for crate::output::OrientToFace {
    fn from(settings: CameraSettings) -> Self {
        Self { settings }
    }
}
impl From<CameraSettings> for crate::output::ViewIsometric {
    fn from(settings: CameraSettings) -> Self {
        Self { settings }
    }
}

/// Defines a perspective view.
#[derive(Copy, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Clone, PartialOrd, Default, Builder)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct PerspectiveCameraParameters {
    /// Camera frustum vertical field of view.
    pub fov_y: Option<f32>,
    /// Camera frustum near plane.
    pub z_near: Option<f32>,
    /// Camera frustum far plane.
    pub z_far: Option<f32>,
}

/// A type of camera movement applied after certain camera operations
#[derive(
    Default,
    Display,
    FromStr,
    Copy,
    Eq,
    PartialEq,
    Debug,
    JsonSchema,
    Deserialize,
    Serialize,
    Sequence,
    Clone,
    Ord,
    PartialOrd,
)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum CameraMovement {
    /// Adjusts the camera position during the camera operation
    #[default]
    Vantage,
    /// Keeps the camera position in place
    None,
}

/// The global axes.
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum GlobalAxis {
    /// The X axis
    X,
    /// The Y axis
    Y,
    /// The Z axis
    Z,
}

/// Possible types of faces which can be extruded from a 3D solid.
#[derive(
    Display, FromStr, Copy, Eq, PartialEq, Debug, JsonSchema, Deserialize, Serialize, Sequence, Clone, Ord, PartialOrd,
)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[repr(u8)]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum ExtrusionFaceCapType {
    /// Uncapped.
    None,
    /// Capped on top.
    Top,
    /// Capped below.
    Bottom,
    /// Capped on both ends.
    Both,
}

/// Post effect type
#[allow(missing_docs)]
#[derive(
    Display,
    FromStr,
    Copy,
    Eq,
    PartialEq,
    Debug,
    JsonSchema,
    Deserialize,
    Serialize,
    Sequence,
    Clone,
    Ord,
    PartialOrd,
    Default,
)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum PostEffectType {
    Phosphor,
    Ssao,
    #[default]
    NoEffect,
}

// Enum: Connect Rust Enums to Cpp
// add our native c++ names for our cxx::ExternType implementation
#[cfg(feature = "cxx")]
impl_extern_type! {
    [Trivial]
    // File
    FileImportFormat = "Enums::_FileImportFormat"
    FileExportFormat = "Enums::_FileExportFormat"
    // Camera
    CameraDragInteractionType = "Enums::_CameraDragInteractionType"
    // Scene
    SceneSelectionType = "Enums::_SceneSelectionType"
    SceneToolType = "Enums::_SceneToolType"
    BlendType = "Enums::_BlendType"
    BodyType = "Enums::_BodyType"
    EntityType = "Enums::_EntityType"
    AnnotationType = "Enums::_AnnotationType"
    AnnotationTextAlignmentX = "Enums::_AnnotationTextAlignmentX"
    AnnotationTextAlignmentY = "Enums::_AnnotationTextAlignmentY"
    AnnotationLineEnd = "Enums::_AnnotationLineEnd"
    MbdStandard = "Enums::_MBDStandard"
    MbdSymbol = "Enums::_MBDSymbol"

    CurveType = "Enums::_CurveType"
    PathCommand = "Enums::_PathCommand"
    PathComponentConstraintBound = "Enums::_PathComponentConstraintBound"
    PathComponentConstraintType = "Enums::_PathComponentConstraintType"
    ExtrusionFaceCapType  = "Enums::_ExtrusionFaceCapType"

    // Utils
    EngineErrorCode = "Enums::_ErrorCode"
    GlobalAxis = "Enums::_GlobalAxis"
    OriginType = "Enums::_OriginType"

    // Graphics engine
    PostEffectType = "Enums::_PostEffectType"
}

fn bool_true() -> bool {
    true
}
fn same_scale() -> Point3d<f64> {
    Point3d::uniform(1.0)
}

fn z_axis() -> Point3d<f64> {
    Point3d { x: 0.0, y: 0.0, z: 1.0 }
}

impl ExtrudedFaceInfo {
    /// Converts from the representation used in the Extrude modeling command,
    /// to a flat representation.
    pub fn list_faces(self) -> Vec<ExtrusionFaceInfo> {
        let mut face_infos: Vec<_> = self
            .sides
            .into_iter()
            .map(|side| ExtrusionFaceInfo {
                curve_id: Some(side.path_id),
                face_id: Some(side.face_id),
                cap: ExtrusionFaceCapType::None,
            })
            .collect();
        face_infos.push(ExtrusionFaceInfo {
            curve_id: None,
            face_id: Some(self.top),
            cap: ExtrusionFaceCapType::Top,
        });
        if let Some(bottom) = self.bottom {
            face_infos.push(ExtrusionFaceInfo {
                curve_id: None,
                face_id: Some(bottom),
                cap: ExtrusionFaceCapType::Bottom,
            });
        }
        face_infos
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_angle_comparison() {
        let a = Angle::from_degrees(90.0);
        assert!(a < Angle::from_degrees(91.0));
        assert!(a > Angle::from_degrees(89.0));
        assert!(a <= Angle::from_degrees(90.0));
        assert!(a >= Angle::from_degrees(90.0));
        let b = Angle::from_radians(std::f64::consts::FRAC_PI_4);
        assert!(b < Angle::from_radians(std::f64::consts::FRAC_PI_2));
        assert!(b > Angle::from_radians(std::f64::consts::FRAC_PI_8));
        assert!(b <= Angle::from_radians(std::f64::consts::FRAC_PI_4));
        assert!(b >= Angle::from_radians(std::f64::consts::FRAC_PI_4));
        // Mixed units.
        assert!(a > b);
        assert!(a >= b);
        assert!(b < a);
        assert!(b <= a);
        let c = Angle::from_radians(std::f64::consts::FRAC_PI_2 * 3.0);
        assert!(a < c);
        assert!(a <= c);
        assert!(c > a);
        assert!(c >= a);
    }
}

/// How a property of an object should be transformed.
#[derive(Clone, Debug, PartialEq, Deserialize, Serialize, JsonSchema, Builder)]
#[schemars(rename = "TransformByFor{T}")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct TransformBy<T> {
    /// The scale, or rotation, or translation.
    pub property: T,
    /// If true, overwrite the previous value with this.
    /// If false, the previous value will be modified.
    /// E.g. when translating, `set=true` will set a new location,
    /// and `set=false` will translate the current location by the given X/Y/Z.
    pub set: bool,
    /// What to use as the origin for the transformation.
    #[serde(default)]
    #[builder(default)]
    pub origin: OriginType,
}

impl<T> TransformBy<T> {
    /// Get the origin of this transformation.
    /// Reads from the `origin` field if it's set, otherwise
    /// falls back to the `is_local` field.
    pub fn get_origin(&self) -> OriginType {
        self.origin
    }
}

/// Container that holds a translate, rotate and scale.
/// Defaults to no change, everything stays the same (i.e. the identity function).
#[derive(Clone, Debug, PartialEq, Deserialize, JsonSchema, Serialize, Default, Builder)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct ComponentTransform {
    /// Translate component of the transform.
    pub translate: Option<TransformBy<Point3d<LengthUnit>>>,
    /// Rotate component of the transform.
    /// The rotation is specified as a roll, pitch, yaw.
    pub rotate_rpy: Option<TransformBy<Point3d<f64>>>,
    /// Rotate component of the transform.
    /// The rotation is specified as an axis and an angle (xyz are the components of the axis, w is
    /// the angle in degrees).
    pub rotate_angle_axis: Option<TransformBy<Point4d<f64>>>,
    /// Scale component of the transform.
    pub scale: Option<TransformBy<Point3d<f64>>>,
}

///If bidirectional or symmetric operations are needed this enum encapsulates the required
///information.
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum Opposite<T> {
    /// No opposite. The operation will only occur on one side.
    #[default]
    None,
    /// Operation will occur from both sides, with the same value.
    Symmetric,
    /// Operation will occur from both sides, with this value for the opposite.
    Other(T),
}

impl<T: JsonSchema> JsonSchema for Opposite<T> {
    fn schema_name() -> String {
        format!("OppositeFor{}", T::schema_name())
    }

    fn schema_id() -> std::borrow::Cow<'static, str> {
        std::borrow::Cow::Owned(format!("{}::Opposite<{}>", module_path!(), T::schema_id()))
    }

    fn json_schema(_: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
        SchemaObject {
            instance_type: Some(schemars::schema::InstanceType::String.into()),
            ..Default::default()
        }
        .into()
    }
}

/// What strategy (algorithm) should be used for cutting?
/// Defaults to Automatic.
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema, Default)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum CutStrategy {
    /// Basic fillet cut. This has limitations, like the filletted edges
    /// can't touch each other. But it's very fast and simple.
    Basic,
    /// More complicated fillet cut. It works for more use-cases, like
    /// edges that touch each other. But it's slower than the Basic method.
    Csg,
    /// Tries the Basic method, and if that doesn't work, tries the CSG strategy.
    #[default]
    Automatic,
}

/// What is the given geometry relative to?
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema, Default)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum RelativeTo {
    /// Local/relative to a position centered within the plane being sketched on
    #[default]
    SketchPlane,
    /// Local/relative to the trajectory curve
    TrajectoryCurve,
}

/// The region a user clicked on.
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema, Builder)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct SelectedRegion {
    /// First segment to follow to find the region.
    pub segment: Uuid,
    /// Second segment to follow to find the region.
    /// Intersects the first segment.
    pub intersection_segment: Uuid,
    /// At which intersection between `segment` and `intersection_segment`
    /// should we stop following the `segment` and start following `intersection_segment`?
    /// Defaults to -1, which means the last intersection.
    #[serde(default = "negative_one")]
    pub intersection_index: i32,
    /// By default (when this is false), curve counterclockwise at intersections.
    /// If this is true, instead curve clockwise.
    #[serde(default)]
    pub curve_clockwise: bool,
}

impl Default for SelectedRegion {
    fn default() -> Self {
        Self {
            segment: Default::default(),
            intersection_segment: Default::default(),
            intersection_index: -1,
            curve_clockwise: Default::default(),
        }
    }
}

/// An edge id and an upper and lower percentage bound of the edge.
#[derive(Builder, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct FractionOfEdge {
    /// The id of the edge (legacy). If both `edge_id` and `edge_specifier` are provided, `edge_specifier` takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edge_id: Option<Uuid>,
    /// Edge specifier (side_faces, end_faces, index) identifying the edge. If both `edge_id` and `edge_specifier` are provided, `edge_specifier` takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edge_specifier: Option<EdgeSpecifier>,
    /// A value between [0.0, 1.0] (default 0.0) that is a percentage along the edge. This bound
    /// will control how much of the edge is used during the blend.
    /// If lower_bound is larger than upper_bound, the edge is effectively "flipped".
    #[serde(default)]
    #[builder(default)]
    #[schemars(range(min = 0, max = 1))]
    pub lower_bound: f32,
    /// A value between [0.0, 1.0] (default 1.0) that is a percentage along the edge. This bound
    /// will control how much of the edge is used during the blend.
    /// If lower_bound is larger than upper_bound, the edge is effectively "flipped".
    #[serde(default = "one")]
    #[builder(default = one())]
    #[schemars(range(min = 0, max = 1))]
    pub upper_bound: f32,
}

/// An object id, that corresponds to a surface body, and a list of edges of the surface.
#[derive(Builder, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct SurfaceEdgeReference {
    /// The id of the body.
    pub object_id: Uuid,
    /// A list of the edge ids that belong to the body.
    pub edges: Vec<FractionOfEdge>,
}

/// List of bodies that were created by an operation.
#[derive(Builder, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Default)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct BodiesCreated {
    /// All bodies created by this operation.
    pub bodies: Vec<BodyCreated>,
}

impl BodiesCreated {
    /// Are there any bodies in this list?
    pub fn is_empty(&self) -> bool {
        self.bodies.is_empty()
    }
}

/// List of bodies that were updated by an operation.
#[derive(Builder, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Default)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct BodiesUpdated {
    /// All bodies created by this operation.
    pub bodies: Vec<BodyUpdated>,
}

impl BodiesUpdated {
    /// Are there any bodies in this list?
    pub fn is_empty(&self) -> bool {
        self.bodies.is_empty()
    }
}

/// Details of a body that was created.
#[derive(Builder, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct BodyCreated {
    /// The body's ID.
    pub id: Uuid,
    /// Surfaces this body contains.
    pub surfaces: Vec<SurfaceCreated>,
}

/// Details of a body that was updated.
#[derive(Builder, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct BodyUpdated {
    /// The body's ID.
    pub id: Uuid,
    /// Surfaces added to this body.
    pub surfaces: Vec<SurfaceCreated>,
}

/// Details of a surface that was created under some body.
#[derive(Builder, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub struct SurfaceCreated {
    /// The surface's ID.
    pub id: Uuid,
    /// Which number face of the parent body is this?
    pub primitive_face_index: u32,
    /// Which segment IDs was this surface swept from?
    pub from_segments: Vec<Uuid>,
}

/// Region-creation algorithm version.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Default)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
pub enum RegionVersion {
    /// The original region creation method. This should NOT be used anymore,
    /// but is maintained to avoid breaking old models.
    #[default]
    V0,
    /// Fixes the bug in V0 where creating a region would shuffle the mapping
    /// from segment names/IDs to actual segment geometry.
    V1,
}

/// Edge cut algorithm version.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema, Copy)]
#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[cfg_attr(feature = "ts-rs", ts(export_to = "ModelingCmd.ts"))]
#[cfg_attr(not(feature = "unstable_exhaustive"), non_exhaustive)]
#[serde(rename_all = "snake_case")]
pub enum EdgeCutVersion {
    /// Let the engine choose whichever version it wants.
    V0,
    /// The original fillet algorithm Zoo 1.0 shipped with.
    /// Limitations: doesn't support rolling ball fillets, has several bugs
    /// that will not be fixed.
    V1,
    /// Adds support for rolling ball fillets.
    /// Fixes bugs from V1.
    /// Still experimental.
    V2,
}

const DEFAULT_EDGE_CUT_VERSION: EdgeCutVersion = EdgeCutVersion::V1;

impl EdgeCutVersion {
    /// Is this the default edge cut algorithm version?
    pub fn is_default(&self) -> bool {
        self == &DEFAULT_EDGE_CUT_VERSION
    }
}

impl Default for EdgeCutVersion {
    fn default() -> Self {
        DEFAULT_EDGE_CUT_VERSION
    }
}

/// Try to match an integer to a version number.
impl TryFrom<u32> for EdgeCutVersion {
    type Error = ();

    fn try_from(version: u32) -> Result<Self, Self::Error> {
        match version {
            0 => Ok(Self::V0),
            1 => Ok(Self::V1),
            2 => Ok(Self::V2),
            _ => Err(()),
        }
    }
}

impl RegionVersion {
    /// Is the version V0?
    pub fn is_zero(&self) -> bool {
        matches!(self, Self::V0)
    }
}

impl From<BodyCreated> for BodyUpdated {
    fn from(body: BodyCreated) -> Self {
        Self {
            id: body.id,
            surfaces: body.surfaces,
        }
    }
}

impl From<BodyUpdated> for BodyCreated {
    fn from(body: BodyUpdated) -> Self {
        Self {
            id: body.id,
            surfaces: body.surfaces,
        }
    }
}

impl From<BodiesCreated> for BodiesUpdated {
    fn from(bodies: BodiesCreated) -> Self {
        Self {
            bodies: bodies.bodies.into_iter().map(Into::into).collect(),
        }
    }
}

impl From<BodiesUpdated> for BodiesCreated {
    fn from(bodies: BodiesUpdated) -> Self {
        Self {
            bodies: bodies.bodies.into_iter().map(Into::into).collect(),
        }
    }
}

fn one() -> f32 {
    1.0
}

/// A debug-view of the segment of a curve.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, JsonSchema, Builder)]
pub struct CurveDebug {
    /// Start point of segment or circle.
    pub start: Option<Point2d<f64>>,
    /// End point of segment.
    pub end: Option<Point2d<f64>>,
    /// Center point of segment.
    pub center: Option<Point2d<f64>>,
    /// Midpoint on a three point arc
    pub mid: Option<Point2d<f64>>,
    /// What kind of segment is it (line, arc, etc)
    pub segment_type: CurveTypeDebug,
    /// ID for this segment.
    pub id: ModelingCmdId,
}

/// What type of curve is being viewed?
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum CurveTypeDebug {
    /// Line with a start and end.
    Line,
    /// Arc with a start, end and center.
    ThreePointArc,
    /// Circle with a center and radius.
    Circle,
}