kittycad.py/kittycad/models/modeling_cmd.py

from typing import Any, Dict, List, Optional, Type, TypeVar, Union
from uuid import UUID

import attr
from pydantic import BaseModel, GetCoreSchemaHandler
from pydantic_core import CoreSchema, core_schema

from ..models.annotation_options import AnnotationOptions
from ..models.annotation_type import AnnotationType
from ..models.camera_drag_interaction_type import CameraDragInteractionType
from ..models.color import Color
from ..models.image_format import ImageFormat
from ..models.import_file import ImportFile
from ..models.input_format import InputFormat
from ..models.modeling_cmd_id import ModelingCmdId
from ..models.output_format import OutputFormat
from ..models.path_component_constraint_bound import PathComponentConstraintBound
from ..models.path_component_constraint_type import PathComponentConstraintType
from ..models.path_segment import PathSegment
from ..models.point2d import Point2d
from ..models.point3d import Point3d
from ..models.scene_selection_type import SceneSelectionType
from ..models.scene_tool_type import SceneToolType
from ..models.unit_area import UnitArea
from ..models.unit_density import UnitDensity
from ..models.unit_length import UnitLength
from ..models.unit_mass import UnitMass
from ..models.unit_volume import UnitVolume


class start_path(BaseModel):
    """Start a path."""

    type: str = "start_path"


class move_path_pen(BaseModel):
    """Move the path's "pen"."""

    path: ModelingCmdId

    to: Point3d

    type: str = "move_path_pen"


class extend_path(BaseModel):
    """Extend a path by adding a new segment which starts at the path's "pen". If no "pen" location has been set before (via `MovePen`), then the pen is at the origin."""

    path: ModelingCmdId

    segment: PathSegment

    type: str = "extend_path"


class extrude(BaseModel):
    """Extrude a 2D solid."""

    cap: bool

    distance: float

    target: ModelingCmdId

    type: str = "extrude"


class close_path(BaseModel):
    """Closes a path, converting it to a 2D solid."""

    path_id: UUID

    type: str = "close_path"


class camera_drag_start(BaseModel):
    """Camera drag started."""

    interaction: CameraDragInteractionType

    type: str = "camera_drag_start"

    window: Point2d


class camera_drag_move(BaseModel):
    """Camera drag continued."""

    interaction: CameraDragInteractionType

    sequence: Optional[int] = None

    type: str = "camera_drag_move"

    window: Point2d


class camera_drag_end(BaseModel):
    """Camera drag ended."""

    interaction: CameraDragInteractionType

    type: str = "camera_drag_end"

    window: Point2d


class default_camera_look_at(BaseModel):
    """Change what the default camera is looking at."""

    center: Point3d

    type: str = "default_camera_look_at"

    up: Point3d

    vantage: Point3d


class default_camera_zoom(BaseModel):
    """Adjust zoom of the default camera."""

    magnitude: float

    type: str = "default_camera_zoom"


class default_camera_enable_sketch_mode(BaseModel):
    """Enable sketch mode, where users can sketch 2D geometry. Users choose a plane to sketch on."""

    animated: bool

    distance_to_plane: float

    origin: Point3d

    ortho: bool

    type: str = "default_camera_enable_sketch_mode"

    x_axis: Point3d

    y_axis: Point3d


class default_camera_disable_sketch_mode(BaseModel):
    """Disable sketch mode, from the default camera."""

    type: str = "default_camera_disable_sketch_mode"


class default_camera_focus_on(BaseModel):
    """Focus default camera on object."""

    type: str = "default_camera_focus_on"

    uuid: UUID


class export(BaseModel):
    """Export the scene to a file."""

    entity_ids: List[UUID]

    format: OutputFormat

    source_unit: UnitLength

    type: str = "export"


class entity_get_parent_id(BaseModel):
    """What is this entity's parent?"""

    entity_id: UUID

    type: str = "entity_get_parent_id"


class entity_get_num_children(BaseModel):
    """How many children does the entity have?"""

    entity_id: UUID

    type: str = "entity_get_num_children"


class entity_get_child_uuid(BaseModel):
    """What is the UUID of this entity's n-th child?"""

    child_index: int

    entity_id: UUID

    type: str = "entity_get_child_uuid"


class entity_get_all_child_uuids(BaseModel):
    """What are all UUIDs of this entity's children?"""

    entity_id: UUID

    type: str = "entity_get_all_child_uuids"


class edit_mode_enter(BaseModel):
    """Enter edit mode"""

    target: UUID

    type: str = "edit_mode_enter"


class edit_mode_exit(BaseModel):
    """Exit edit mode"""

    type: str = "edit_mode_exit"


class select_with_point(BaseModel):
    """Modifies the selection by simulating a "mouse click" at the given x,y window coordinate Returns ID of whatever was selected."""

    selected_at_window: Point2d

    selection_type: SceneSelectionType

    type: str = "select_with_point"


class select_clear(BaseModel):
    """Clear the selection"""

    type: str = "select_clear"


class select_add(BaseModel):
    """Adds one or more entities (by UUID) to the selection."""

    entities: List[UUID]

    type: str = "select_add"


class select_remove(BaseModel):
    """Removes one or more entities (by UUID) from the selection."""

    entities: List[UUID]

    type: str = "select_remove"


class select_replace(BaseModel):
    """Replaces the current selection with these new entities (by UUID). Equivalent to doing SelectClear then SelectAdd."""

    entities: List[UUID]

    type: str = "select_replace"


class select_get(BaseModel):
    """Find all IDs of selected entities"""

    type: str = "select_get"


class highlight_set_entity(BaseModel):
    """Changes the current highlighted entity to whichever one is at the given window coordinate. If there's no entity at this location, clears the highlight."""

    selected_at_window: Point2d

    sequence: Optional[int] = None

    type: str = "highlight_set_entity"


class highlight_set_entities(BaseModel):
    """Changes the current highlighted entity to these entities."""

    entities: List[UUID]

    type: str = "highlight_set_entities"


class new_annotation(BaseModel):
    """Create a new annotation"""

    annotation_type: AnnotationType

    clobber: bool

    options: AnnotationOptions

    type: str = "new_annotation"


class update_annotation(BaseModel):
    """Update an annotation"""

    annotation_id: UUID

    options: AnnotationOptions

    type: str = "update_annotation"


class object_visible(BaseModel):
    """Hide or show an object"""

    hidden: bool

    object_id: UUID

    type: str = "object_visible"


class object_bring_to_front(BaseModel):
    """Bring an object to the front of the scene"""

    object_id: UUID

    type: str = "object_bring_to_front"


class get_entity_type(BaseModel):
    """What type of entity is this?"""

    entity_id: UUID

    type: str = "get_entity_type"


class solid2d_add_hole(BaseModel):
    """Add a hole to a Solid2d object before extruding it."""

    hole_id: UUID

    object_id: UUID

    type: str = "solid2d_add_hole"


class solid3d_get_all_edge_faces(BaseModel):
    """Gets all faces which use the given edge."""

    edge_id: UUID

    object_id: UUID

    type: str = "solid3d_get_all_edge_faces"


class solid3d_get_all_opposite_edges(BaseModel):
    """Gets all edges which are opposite the given edge, across all possible faces."""

    along_vector: Optional[Point3d] = None

    edge_id: UUID

    object_id: UUID

    type: str = "solid3d_get_all_opposite_edges"


class solid3d_get_opposite_edge(BaseModel):
    """Gets the edge opposite the given edge, along the given face."""

    edge_id: UUID

    face_id: UUID

    object_id: UUID

    type: str = "solid3d_get_opposite_edge"


class solid3d_get_next_adjacent_edge(BaseModel):
    """Gets the next adjacent edge for the given edge, along the given face."""

    edge_id: UUID

    face_id: UUID

    object_id: UUID

    type: str = "solid3d_get_next_adjacent_edge"


class solid3d_get_prev_adjacent_edge(BaseModel):
    """Gets the previous adjacent edge for the given edge, along the given face."""

    edge_id: UUID

    face_id: UUID

    object_id: UUID

    type: str = "solid3d_get_prev_adjacent_edge"


class send_object(BaseModel):
    """Sends object to front or back."""

    front: bool

    object_id: UUID

    type: str = "send_object"


class entity_set_opacity(BaseModel):
    """Set opacity of the entity."""

    entity_id: UUID

    opacity: float

    type: str = "entity_set_opacity"


class entity_fade(BaseModel):
    """Fade the entity in or out."""

    duration_seconds: Optional[float] = None

    entity_id: UUID

    fade_in: bool

    type: str = "entity_fade"


class make_plane(BaseModel):
    """Make a plane."""

    clobber: bool

    hide: Optional[bool] = None

    origin: Point3d

    size: float

    type: str = "make_plane"

    x_axis: Point3d

    y_axis: Point3d


class plane_set_color(BaseModel):
    """Set the plane's color."""

    color: Color

    plane_id: UUID

    type: str = "plane_set_color"


class set_tool(BaseModel):
    """Set the active tool."""

    tool: SceneToolType

    type: str = "set_tool"


class mouse_move(BaseModel):
    """Send a mouse move event."""

    sequence: Optional[int] = None

    type: str = "mouse_move"

    window: Point2d


class mouse_click(BaseModel):
    """Send a mouse click event. Updates modified/selected entities."""

    type: str = "mouse_click"

    window: Point2d


class sketch_mode_enable(BaseModel):
    """Enable sketch mode on the given plane."""

    animated: bool

    disable_camera_with_plane: Optional[Point3d] = None

    ortho: bool

    plane_id: UUID

    type: str = "sketch_mode_enable"


class sketch_mode_disable(BaseModel):
    """Disable sketch mode."""

    type: str = "sketch_mode_disable"


class curve_get_type(BaseModel):
    """Get type of a given curve."""

    curve_id: UUID

    type: str = "curve_get_type"


class curve_get_control_points(BaseModel):
    """Get control points of a given curve."""

    curve_id: UUID

    type: str = "curve_get_control_points"


class take_snapshot(BaseModel):
    """Take a snapshot."""

    format: ImageFormat

    type: str = "take_snapshot"


class make_axes_gizmo(BaseModel):
    """Add a gizmo showing the axes."""

    clobber: bool

    gizmo_mode: bool

    type: str = "make_axes_gizmo"


class path_get_info(BaseModel):
    """Query the given path"""

    path_id: UUID

    type: str = "path_get_info"


class path_get_curve_uuids_for_vertices(BaseModel):
    """Get curves for vertices within a path"""

    path_id: UUID

    type: str = "path_get_curve_uuids_for_vertices"

    vertex_ids: List[UUID]


class path_get_vertex_uuids(BaseModel):
    """Get vertices within a path"""

    path_id: UUID

    type: str = "path_get_vertex_uuids"


class handle_mouse_drag_start(BaseModel):
    """Start dragging mouse."""

    type: str = "handle_mouse_drag_start"

    window: Point2d


class handle_mouse_drag_move(BaseModel):
    """Continue dragging mouse."""

    sequence: Optional[int] = None

    type: str = "handle_mouse_drag_move"

    window: Point2d


class handle_mouse_drag_end(BaseModel):
    """Stop dragging mouse."""

    type: str = "handle_mouse_drag_end"

    window: Point2d


class remove_scene_objects(BaseModel):
    """Remove scene objects."""

    object_ids: List[UUID]

    type: str = "remove_scene_objects"


class plane_intersect_and_project(BaseModel):
    """Utility method. Performs both a ray cast and projection to plane-local coordinates. Returns the plane coordinates for the given window coordinates."""

    plane_id: UUID

    type: str = "plane_intersect_and_project"

    window: Point2d


class curve_get_end_points(BaseModel):
    """Find the start and end of a curve."""

    curve_id: UUID

    type: str = "curve_get_end_points"


class reconfigure_stream(BaseModel):
    """Reconfigure the stream."""

    fps: int

    height: int

    type: str = "reconfigure_stream"

    width: int


class import_files(BaseModel):
    """Import files to the current model."""

    files: List[ImportFile]

    format: InputFormat

    type: str = "import_files"


class mass(BaseModel):
    """Get the mass of entities in the scene or the default scene."""

    entity_ids: List[UUID]

    material_density: float

    material_density_unit: UnitDensity

    output_unit: UnitMass

    source_unit: UnitLength

    type: str = "mass"


class density(BaseModel):
    """Get the density of entities in the scene or the default scene."""

    entity_ids: List[UUID]

    material_mass: float

    material_mass_unit: UnitMass

    output_unit: UnitDensity

    source_unit: UnitLength

    type: str = "density"


class volume(BaseModel):
    """Get the volume of entities in the scene or the default scene."""

    entity_ids: List[UUID]

    output_unit: UnitVolume

    source_unit: UnitLength

    type: str = "volume"


class center_of_mass(BaseModel):
    """Get the center of mass of entities in the scene or the default scene."""

    entity_ids: List[UUID]

    output_unit: UnitLength

    source_unit: UnitLength

    type: str = "center_of_mass"


class surface_area(BaseModel):
    """Get the surface area of entities in the scene or the default scene."""

    entity_ids: List[UUID]

    output_unit: UnitArea

    source_unit: UnitLength

    type: str = "surface_area"


class get_sketch_mode_plane(BaseModel):
    """Get the plane of the sketch mode. This is useful for getting the normal of the plane after a user selects a plane."""

    type: str = "get_sketch_mode_plane"


class curve_set_constraint(BaseModel):
    """Constrain a curve."""

    constraint_bound: PathComponentConstraintBound

    constraint_type: PathComponentConstraintType

    object_id: UUID

    type: str = "curve_set_constraint"


GY = TypeVar("GY", bound="ModelingCmd")


@attr.s(auto_attribs=True)
class ModelingCmd:

    """Commands that the KittyCAD engine can execute."""

    type: Union[
        start_path,
        move_path_pen,
        extend_path,
        extrude,
        close_path,
        camera_drag_start,
        camera_drag_move,
        camera_drag_end,
        default_camera_look_at,
        default_camera_zoom,
        default_camera_enable_sketch_mode,
        default_camera_disable_sketch_mode,
        default_camera_focus_on,
        export,
        entity_get_parent_id,
        entity_get_num_children,
        entity_get_child_uuid,
        entity_get_all_child_uuids,
        edit_mode_enter,
        edit_mode_exit,
        select_with_point,
        select_clear,
        select_add,
        select_remove,
        select_replace,
        select_get,
        highlight_set_entity,
        highlight_set_entities,
        new_annotation,
        update_annotation,
        object_visible,
        object_bring_to_front,
        get_entity_type,
        solid2d_add_hole,
        solid3d_get_all_edge_faces,
        solid3d_get_all_opposite_edges,
        solid3d_get_opposite_edge,
        solid3d_get_next_adjacent_edge,
        solid3d_get_prev_adjacent_edge,
        send_object,
        entity_set_opacity,
        entity_fade,
        make_plane,
        plane_set_color,
        set_tool,
        mouse_move,
        mouse_click,
        sketch_mode_enable,
        sketch_mode_disable,
        curve_get_type,
        curve_get_control_points,
        take_snapshot,
        make_axes_gizmo,
        path_get_info,
        path_get_curve_uuids_for_vertices,
        path_get_vertex_uuids,
        handle_mouse_drag_start,
        handle_mouse_drag_move,
        handle_mouse_drag_end,
        remove_scene_objects,
        plane_intersect_and_project,
        curve_get_end_points,
        reconfigure_stream,
        import_files,
        mass,
        density,
        volume,
        center_of_mass,
        surface_area,
        get_sketch_mode_plane,
        curve_set_constraint,
    ]

    def __init__(
        self,
        type: Union[
            start_path,
            move_path_pen,
            extend_path,
            extrude,
            close_path,
            camera_drag_start,
            camera_drag_move,
            camera_drag_end,
            default_camera_look_at,
            default_camera_zoom,
            default_camera_enable_sketch_mode,
            default_camera_disable_sketch_mode,
            default_camera_focus_on,
            export,
            entity_get_parent_id,
            entity_get_num_children,
            entity_get_child_uuid,
            entity_get_all_child_uuids,
            edit_mode_enter,
            edit_mode_exit,
            select_with_point,
            select_clear,
            select_add,
            select_remove,
            select_replace,
            select_get,
            highlight_set_entity,
            highlight_set_entities,
            new_annotation,
            update_annotation,
            object_visible,
            object_bring_to_front,
            get_entity_type,
            solid2d_add_hole,
            solid3d_get_all_edge_faces,
            solid3d_get_all_opposite_edges,
            solid3d_get_opposite_edge,
            solid3d_get_next_adjacent_edge,
            solid3d_get_prev_adjacent_edge,
            send_object,
            entity_set_opacity,
            entity_fade,
            make_plane,
            plane_set_color,
            set_tool,
            mouse_move,
            mouse_click,
            sketch_mode_enable,
            sketch_mode_disable,
            curve_get_type,
            curve_get_control_points,
            take_snapshot,
            make_axes_gizmo,
            path_get_info,
            path_get_curve_uuids_for_vertices,
            path_get_vertex_uuids,
            handle_mouse_drag_start,
            handle_mouse_drag_move,
            handle_mouse_drag_end,
            remove_scene_objects,
            plane_intersect_and_project,
            curve_get_end_points,
            reconfigure_stream,
            import_files,
            mass,
            density,
            volume,
            center_of_mass,
            surface_area,
            get_sketch_mode_plane,
            curve_set_constraint,
        ],
    ):
        self.type = type

    def model_dump(self) -> Dict[str, Any]:
        if isinstance(self.type, start_path):
            ON: start_path = self.type
            return ON.model_dump()
        elif isinstance(self.type, move_path_pen):
            US: move_path_pen = self.type
            return US.model_dump()
        elif isinstance(self.type, extend_path):
            FH: extend_path = self.type
            return FH.model_dump()
        elif isinstance(self.type, extrude):
            BB: extrude = self.type
            return BB.model_dump()
        elif isinstance(self.type, close_path):
            TV: close_path = self.type
            return TV.model_dump()
        elif isinstance(self.type, camera_drag_start):
            CE: camera_drag_start = self.type
            return CE.model_dump()
        elif isinstance(self.type, camera_drag_move):
            LT: camera_drag_move = self.type
            return LT.model_dump()
        elif isinstance(self.type, camera_drag_end):
            YY: camera_drag_end = self.type
            return YY.model_dump()
        elif isinstance(self.type, default_camera_look_at):
            FZ: default_camera_look_at = self.type
            return FZ.model_dump()
        elif isinstance(self.type, default_camera_zoom):
            NN: default_camera_zoom = self.type
            return NN.model_dump()
        elif isinstance(self.type, default_camera_enable_sketch_mode):
            VI: default_camera_enable_sketch_mode = self.type
            return VI.model_dump()
        elif isinstance(self.type, default_camera_disable_sketch_mode):
            QF: default_camera_disable_sketch_mode = self.type
            return QF.model_dump()
        elif isinstance(self.type, default_camera_focus_on):
            OJ: default_camera_focus_on = self.type
            return OJ.model_dump()
        elif isinstance(self.type, export):
            YF: export = self.type
            return YF.model_dump()
        elif isinstance(self.type, entity_get_parent_id):
            LK: entity_get_parent_id = self.type
            return LK.model_dump()
        elif isinstance(self.type, entity_get_num_children):
            WB: entity_get_num_children = self.type
            return WB.model_dump()
        elif isinstance(self.type, entity_get_child_uuid):
            HC: entity_get_child_uuid = self.type
            return HC.model_dump()
        elif isinstance(self.type, entity_get_all_child_uuids):
            PV: entity_get_all_child_uuids = self.type
            return PV.model_dump()
        elif isinstance(self.type, edit_mode_enter):
            TP: edit_mode_enter = self.type
            return TP.model_dump()
        elif isinstance(self.type, edit_mode_exit):
            OM: edit_mode_exit = self.type
            return OM.model_dump()
        elif isinstance(self.type, select_with_point):
            RS: select_with_point = self.type
            return RS.model_dump()
        elif isinstance(self.type, select_clear):
            MP: select_clear = self.type
            return MP.model_dump()
        elif isinstance(self.type, select_add):
            RO: select_add = self.type
            return RO.model_dump()
        elif isinstance(self.type, select_remove):
            BA: select_remove = self.type
            return BA.model_dump()
        elif isinstance(self.type, select_replace):
            CB: select_replace = self.type
            return CB.model_dump()
        elif isinstance(self.type, select_get):
            TO: select_get = self.type
            return TO.model_dump()
        elif isinstance(self.type, highlight_set_entity):
            EO: highlight_set_entity = self.type
            return EO.model_dump()
        elif isinstance(self.type, highlight_set_entities):
            QO: highlight_set_entities = self.type
            return QO.model_dump()
        elif isinstance(self.type, new_annotation):
            IZ: new_annotation = self.type
            return IZ.model_dump()
        elif isinstance(self.type, update_annotation):
            NK: update_annotation = self.type
            return NK.model_dump()
        elif isinstance(self.type, object_visible):
            QE: object_visible = self.type
            return QE.model_dump()
        elif isinstance(self.type, object_bring_to_front):
            KT: object_bring_to_front = self.type
            return KT.model_dump()
        elif isinstance(self.type, get_entity_type):
            GU: get_entity_type = self.type
            return GU.model_dump()
        elif isinstance(self.type, solid2d_add_hole):
            UP: solid2d_add_hole = self.type
            return UP.model_dump()
        elif isinstance(self.type, solid3d_get_all_edge_faces):
            DJ: solid3d_get_all_edge_faces = self.type
            return DJ.model_dump()
        elif isinstance(self.type, solid3d_get_all_opposite_edges):
            TR: solid3d_get_all_opposite_edges = self.type
            return TR.model_dump()
        elif isinstance(self.type, solid3d_get_opposite_edge):
            JF: solid3d_get_opposite_edge = self.type
            return JF.model_dump()
        elif isinstance(self.type, solid3d_get_next_adjacent_edge):
            EL: solid3d_get_next_adjacent_edge = self.type
            return EL.model_dump()
        elif isinstance(self.type, solid3d_get_prev_adjacent_edge):
            LF: solid3d_get_prev_adjacent_edge = self.type
            return LF.model_dump()
        elif isinstance(self.type, send_object):
            GN: send_object = self.type
            return GN.model_dump()
        elif isinstance(self.type, entity_set_opacity):
            VJ: entity_set_opacity = self.type
            return VJ.model_dump()
        elif isinstance(self.type, entity_fade):
            YW: entity_fade = self.type
            return YW.model_dump()
        elif isinstance(self.type, make_plane):
            NO: make_plane = self.type
            return NO.model_dump()
        elif isinstance(self.type, plane_set_color):
            RG: plane_set_color = self.type
            return RG.model_dump()
        elif isinstance(self.type, set_tool):
            LD: set_tool = self.type
            return LD.model_dump()
        elif isinstance(self.type, mouse_move):
            TN: mouse_move = self.type
            return TN.model_dump()
        elif isinstance(self.type, mouse_click):
            UG: mouse_click = self.type
            return UG.model_dump()
        elif isinstance(self.type, sketch_mode_enable):
            NZ: sketch_mode_enable = self.type
            return NZ.model_dump()
        elif isinstance(self.type, sketch_mode_disable):
            LO: sketch_mode_disable = self.type
            return LO.model_dump()
        elif isinstance(self.type, curve_get_type):
            OW: curve_get_type = self.type
            return OW.model_dump()
        elif isinstance(self.type, curve_get_control_points):
            PQ: curve_get_control_points = self.type
            return PQ.model_dump()
        elif isinstance(self.type, take_snapshot):
            OU: take_snapshot = self.type
            return OU.model_dump()
        elif isinstance(self.type, make_axes_gizmo):
            XI: make_axes_gizmo = self.type
            return XI.model_dump()
        elif isinstance(self.type, path_get_info):
            PS: path_get_info = self.type
            return PS.model_dump()
        elif isinstance(self.type, path_get_curve_uuids_for_vertices):
            XL: path_get_curve_uuids_for_vertices = self.type
            return XL.model_dump()
        elif isinstance(self.type, path_get_vertex_uuids):
            FT: path_get_vertex_uuids = self.type
            return FT.model_dump()
        elif isinstance(self.type, handle_mouse_drag_start):
            SC: handle_mouse_drag_start = self.type
            return SC.model_dump()
        elif isinstance(self.type, handle_mouse_drag_move):
            JA: handle_mouse_drag_move = self.type
            return JA.model_dump()
        elif isinstance(self.type, handle_mouse_drag_end):
            UK: handle_mouse_drag_end = self.type
            return UK.model_dump()
        elif isinstance(self.type, remove_scene_objects):
            MT: remove_scene_objects = self.type
            return MT.model_dump()
        elif isinstance(self.type, plane_intersect_and_project):
            TF: plane_intersect_and_project = self.type
            return TF.model_dump()
        elif isinstance(self.type, curve_get_end_points):
            JD: curve_get_end_points = self.type
            return JD.model_dump()
        elif isinstance(self.type, reconfigure_stream):
            BH: reconfigure_stream = self.type
            return BH.model_dump()
        elif isinstance(self.type, import_files):
            CN: import_files = self.type
            return CN.model_dump()
        elif isinstance(self.type, mass):
            SO: mass = self.type
            return SO.model_dump()
        elif isinstance(self.type, density):
            AM: density = self.type
            return AM.model_dump()
        elif isinstance(self.type, volume):
            SG: volume = self.type
            return SG.model_dump()
        elif isinstance(self.type, center_of_mass):
            SY: center_of_mass = self.type
            return SY.model_dump()
        elif isinstance(self.type, surface_area):
            WS: surface_area = self.type
            return WS.model_dump()
        elif isinstance(self.type, get_sketch_mode_plane):
            MK: get_sketch_mode_plane = self.type
            return MK.model_dump()
        elif isinstance(self.type, curve_set_constraint):
            FY: curve_set_constraint = self.type
            return FY.model_dump()

        raise Exception("Unknown type")

    @classmethod
    def from_dict(cls: Type[GY], d: Dict[str, Any]) -> GY:
        if d.get("type") == "start_path":
            PC: start_path = start_path(**d)
            return cls(type=PC)
        elif d.get("type") == "move_path_pen":
            KQ: move_path_pen = move_path_pen(**d)
            return cls(type=KQ)
        elif d.get("type") == "extend_path":
            NH: extend_path = extend_path(**d)
            return cls(type=NH)
        elif d.get("type") == "extrude":
            PJ: extrude = extrude(**d)
            return cls(type=PJ)
        elif d.get("type") == "close_path":
            CR: close_path = close_path(**d)
            return cls(type=CR)
        elif d.get("type") == "camera_drag_start":
            MS: camera_drag_start = camera_drag_start(**d)
            return cls(type=MS)
        elif d.get("type") == "camera_drag_move":
            ED: camera_drag_move = camera_drag_move(**d)
            return cls(type=ED)
        elif d.get("type") == "camera_drag_end":
            DO: camera_drag_end = camera_drag_end(**d)
            return cls(type=DO)
        elif d.get("type") == "default_camera_look_at":
            GL: default_camera_look_at = default_camera_look_at(**d)
            return cls(type=GL)
        elif d.get("type") == "default_camera_zoom":
            OH: default_camera_zoom = default_camera_zoom(**d)
            return cls(type=OH)
        elif d.get("type") == "default_camera_enable_sketch_mode":
            ET: default_camera_enable_sketch_mode = default_camera_enable_sketch_mode(
                **d
            )
            return cls(type=ET)
        elif d.get("type") == "default_camera_disable_sketch_mode":
            DI: default_camera_disable_sketch_mode = default_camera_disable_sketch_mode(
                **d
            )
            return cls(type=DI)
        elif d.get("type") == "default_camera_focus_on":
            UF: default_camera_focus_on = default_camera_focus_on(**d)
            return cls(type=UF)
        elif d.get("type") == "export":
            PY: export = export(**d)
            return cls(type=PY)
        elif d.get("type") == "entity_get_parent_id":
            AR: entity_get_parent_id = entity_get_parent_id(**d)
            return cls(type=AR)
        elif d.get("type") == "entity_get_num_children":
            KK: entity_get_num_children = entity_get_num_children(**d)
            return cls(type=KK)
        elif d.get("type") == "entity_get_child_uuid":
            FM: entity_get_child_uuid = entity_get_child_uuid(**d)
            return cls(type=FM)
        elif d.get("type") == "entity_get_all_child_uuids":
            QI: entity_get_all_child_uuids = entity_get_all_child_uuids(**d)
            return cls(type=QI)
        elif d.get("type") == "edit_mode_enter":
            CF: edit_mode_enter = edit_mode_enter(**d)
            return cls(type=CF)
        elif d.get("type") == "edit_mode_exit":
            EN: edit_mode_exit = edit_mode_exit(**d)
            return cls(type=EN)
        elif d.get("type") == "select_with_point":
            LR: select_with_point = select_with_point(**d)
            return cls(type=LR)
        elif d.get("type") == "select_clear":
            WF: select_clear = select_clear(**d)
            return cls(type=WF)
        elif d.get("type") == "select_add":
            DN: select_add = select_add(**d)
            return cls(type=DN)
        elif d.get("type") == "select_remove":
            OR: select_remove = select_remove(**d)
            return cls(type=OR)
        elif d.get("type") == "select_replace":
            LC: select_replace = select_replace(**d)
            return cls(type=LC)
        elif d.get("type") == "select_get":
            ZP: select_get = select_get(**d)
            return cls(type=ZP)
        elif d.get("type") == "highlight_set_entity":
            NY: highlight_set_entity = highlight_set_entity(**d)
            return cls(type=NY)
        elif d.get("type") == "highlight_set_entities":
            KX: highlight_set_entities = highlight_set_entities(**d)
            return cls(type=KX)
        elif d.get("type") == "new_annotation":
            WO: new_annotation = new_annotation(**d)
            return cls(type=WO)
        elif d.get("type") == "update_annotation":
            UQ: update_annotation = update_annotation(**d)
            return cls(type=UQ)
        elif d.get("type") == "object_visible":
            XH: object_visible = object_visible(**d)
            return cls(type=XH)
        elif d.get("type") == "object_bring_to_front":
            BV: object_bring_to_front = object_bring_to_front(**d)
            return cls(type=BV)
        elif d.get("type") == "get_entity_type":
            SS: get_entity_type = get_entity_type(**d)
            return cls(type=SS)
        elif d.get("type") == "solid2d_add_hole":
            AZ: solid2d_add_hole = solid2d_add_hole(**d)
            return cls(type=AZ)
        elif d.get("type") == "solid3d_get_all_edge_faces":
            WJ: solid3d_get_all_edge_faces = solid3d_get_all_edge_faces(**d)
            return cls(type=WJ)
        elif d.get("type") == "solid3d_get_all_opposite_edges":
            YD: solid3d_get_all_opposite_edges = solid3d_get_all_opposite_edges(**d)
            return cls(type=YD)
        elif d.get("type") == "solid3d_get_opposite_edge":
            VP: solid3d_get_opposite_edge = solid3d_get_opposite_edge(**d)
            return cls(type=VP)
        elif d.get("type") == "solid3d_get_next_adjacent_edge":
            ZG: solid3d_get_next_adjacent_edge = solid3d_get_next_adjacent_edge(**d)
            return cls(type=ZG)
        elif d.get("type") == "solid3d_get_prev_adjacent_edge":
            CS: solid3d_get_prev_adjacent_edge = solid3d_get_prev_adjacent_edge(**d)
            return cls(type=CS)
        elif d.get("type") == "send_object":
            GD: send_object = send_object(**d)
            return cls(type=GD)
        elif d.get("type") == "entity_set_opacity":
            OX: entity_set_opacity = entity_set_opacity(**d)
            return cls(type=OX)
        elif d.get("type") == "entity_fade":
            QX: entity_fade = entity_fade(**d)
            return cls(type=QX)
        elif d.get("type") == "make_plane":
            VX: make_plane = make_plane(**d)
            return cls(type=VX)
        elif d.get("type") == "plane_set_color":
            IT: plane_set_color = plane_set_color(**d)
            return cls(type=IT)
        elif d.get("type") == "set_tool":
            UA: set_tool = set_tool(**d)
            return cls(type=UA)
        elif d.get("type") == "mouse_move":
            MZ: mouse_move = mouse_move(**d)
            return cls(type=MZ)
        elif d.get("type") == "mouse_click":
            CY: mouse_click = mouse_click(**d)
            return cls(type=CY)
        elif d.get("type") == "sketch_mode_enable":
            LI: sketch_mode_enable = sketch_mode_enable(**d)
            return cls(type=LI)
        elif d.get("type") == "sketch_mode_disable":
            XJ: sketch_mode_disable = sketch_mode_disable(**d)
            return cls(type=XJ)
        elif d.get("type") == "curve_get_type":
            JQ: curve_get_type = curve_get_type(**d)
            return cls(type=JQ)
        elif d.get("type") == "curve_get_control_points":
            IM: curve_get_control_points = curve_get_control_points(**d)
            return cls(type=IM)
        elif d.get("type") == "take_snapshot":
            KL: take_snapshot = take_snapshot(**d)
            return cls(type=KL)
        elif d.get("type") == "make_axes_gizmo":
            PO: make_axes_gizmo = make_axes_gizmo(**d)
            return cls(type=PO)
        elif d.get("type") == "path_get_info":
            WR: path_get_info = path_get_info(**d)
            return cls(type=WR)
        elif d.get("type") == "path_get_curve_uuids_for_vertices":
            ZX: path_get_curve_uuids_for_vertices = path_get_curve_uuids_for_vertices(
                **d
            )
            return cls(type=ZX)
        elif d.get("type") == "path_get_vertex_uuids":
            NX: path_get_vertex_uuids = path_get_vertex_uuids(**d)
            return cls(type=NX)
        elif d.get("type") == "handle_mouse_drag_start":
            TX: handle_mouse_drag_start = handle_mouse_drag_start(**d)
            return cls(type=TX)
        elif d.get("type") == "handle_mouse_drag_move":
            SK: handle_mouse_drag_move = handle_mouse_drag_move(**d)
            return cls(type=SK)
        elif d.get("type") == "handle_mouse_drag_end":
            CX: handle_mouse_drag_end = handle_mouse_drag_end(**d)
            return cls(type=CX)
        elif d.get("type") == "remove_scene_objects":
            LJ: remove_scene_objects = remove_scene_objects(**d)
            return cls(type=LJ)
        elif d.get("type") == "plane_intersect_and_project":
            HF: plane_intersect_and_project = plane_intersect_and_project(**d)
            return cls(type=HF)
        elif d.get("type") == "curve_get_end_points":
            RZ: curve_get_end_points = curve_get_end_points(**d)
            return cls(type=RZ)
        elif d.get("type") == "reconfigure_stream":
            SX: reconfigure_stream = reconfigure_stream(**d)
            return cls(type=SX)
        elif d.get("type") == "import_files":
            GS: import_files = import_files(**d)
            return cls(type=GS)
        elif d.get("type") == "mass":
            ZS: mass = mass(**d)
            return cls(type=ZS)
        elif d.get("type") == "density":
            GK: density = density(**d)
            return cls(type=GK)
        elif d.get("type") == "volume":
            QZ: volume = volume(**d)
            return cls(type=QZ)
        elif d.get("type") == "center_of_mass":
            YK: center_of_mass = center_of_mass(**d)
            return cls(type=YK)
        elif d.get("type") == "surface_area":
            SL: surface_area = surface_area(**d)
            return cls(type=SL)
        elif d.get("type") == "get_sketch_mode_plane":
            TU: get_sketch_mode_plane = get_sketch_mode_plane(**d)
            return cls(type=TU)
        elif d.get("type") == "curve_set_constraint":
            FD: curve_set_constraint = curve_set_constraint(**d)
            return cls(type=FD)

        raise Exception("Unknown type")

    @classmethod
    def __get_pydantic_core_schema__(
        cls, source_type: Any, handler: GetCoreSchemaHandler
    ) -> CoreSchema:
        return core_schema.no_info_after_validator_function(
            cls,
            handler(
                Union[
                    start_path,
                    move_path_pen,
                    extend_path,
                    extrude,
                    close_path,
                    camera_drag_start,
                    camera_drag_move,
                    camera_drag_end,
                    default_camera_look_at,
                    default_camera_zoom,
                    default_camera_enable_sketch_mode,
                    default_camera_disable_sketch_mode,
                    default_camera_focus_on,
                    export,
                    entity_get_parent_id,
                    entity_get_num_children,
                    entity_get_child_uuid,
                    entity_get_all_child_uuids,
                    edit_mode_enter,
                    edit_mode_exit,
                    select_with_point,
                    select_clear,
                    select_add,
                    select_remove,
                    select_replace,
                    select_get,
                    highlight_set_entity,
                    highlight_set_entities,
                    new_annotation,
                    update_annotation,
                    object_visible,
                    object_bring_to_front,
                    get_entity_type,
                    solid2d_add_hole,
                    solid3d_get_all_edge_faces,
                    solid3d_get_all_opposite_edges,
                    solid3d_get_opposite_edge,
                    solid3d_get_next_adjacent_edge,
                    solid3d_get_prev_adjacent_edge,
                    send_object,
                    entity_set_opacity,
                    entity_fade,
                    make_plane,
                    plane_set_color,
                    set_tool,
                    mouse_move,
                    mouse_click,
                    sketch_mode_enable,
                    sketch_mode_disable,
                    curve_get_type,
                    curve_get_control_points,
                    take_snapshot,
                    make_axes_gizmo,
                    path_get_info,
                    path_get_curve_uuids_for_vertices,
                    path_get_vertex_uuids,
                    handle_mouse_drag_start,
                    handle_mouse_drag_move,
                    handle_mouse_drag_end,
                    remove_scene_objects,
                    plane_intersect_and_project,
                    curve_get_end_points,
                    reconfigure_stream,
                    import_files,
                    mass,
                    density,
                    volume,
                    center_of_mass,
                    surface_area,
                    get_sketch_mode_plane,
                    curve_set_constraint,
                ]
            ),
        )