wandelbots_api_client 26.3.0__py3-none-any.whl

wandelbots_api_client/models/plan_collision_free_ptp_request_target.py

@@ -0,0 +1,150 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import json
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional, Union
+from wandelbots_api_client.models.pose2 import Pose2
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+PLANCOLLISIONFREEPTPREQUESTTARGET_ONE_OF_SCHEMAS = ["List[float]", "Pose2"]
+
+
+class PlanCollisionFreePTPRequestTarget(BaseModel):
+    """
+    The target position of the motion. The target can be defined in joint space as joint positions, or cartesian space as TCP pose.
+    """
+
+    # data type: List[float]
+    oneof_schema_1_validator: Optional[List[Union[StrictFloat, StrictInt]]] = None
+    # data type: Pose2
+    oneof_schema_2_validator: Optional[Pose2] = None
+    actual_instance: Optional[Union[List[float], Pose2]] = None
+    one_of_schemas: Set[str] = {"List[float]", "Pose2"}
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator("actual_instance")
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = PlanCollisionFreePTPRequestTarget.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: List[float]
+        try:
+            instance.oneof_schema_1_validator = v
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # validate data type: Pose2
+        if not isinstance(v, Pose2):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `Pose2`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError(
+                "Multiple matches found when setting `actual_instance` in PlanCollisionFreePTPRequestTarget with oneOf schemas: List[float], Pose2. Details: "
+                + ", ".join(error_messages)
+            )
+        elif match == 0:
+            # no match
+            raise ValueError(
+                "No match found when setting `actual_instance` in PlanCollisionFreePTPRequestTarget with oneOf schemas: List[float], Pose2. Details: "
+                + ", ".join(error_messages)
+            )
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # deserialize data into List[float]
+        try:
+            # validation
+            instance.oneof_schema_1_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.oneof_schema_1_validator
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into Pose2
+        try:
+            instance.actual_instance = Pose2.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError(
+                "Multiple matches found when deserializing the JSON string into PlanCollisionFreePTPRequestTarget with oneOf schemas: List[float], Pose2. Details: "
+                + ", ".join(error_messages)
+            )
+        elif match == 0:
+            # no match
+            raise ValueError(
+                "No match found when deserializing the JSON string into PlanCollisionFreePTPRequestTarget with oneOf schemas: List[float], Pose2. Details: "
+                + ", ".join(error_messages)
+            )
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], List[float], Pose2]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())

wandelbots_api_client/models/plan_failed_on_trajectory_response.py

@@ -0,0 +1,149 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from wandelbots_api_client.models.joint_limit_exceeded import JointLimitExceeded
+from wandelbots_api_client.models.joints import Joints
+from wandelbots_api_client.models.out_of_workspace import OutOfWorkspace
+from wandelbots_api_client.models.pose import Pose
+from wandelbots_api_client.models.safety_zone_violation import SafetyZoneViolation
+from wandelbots_api_client.models.singularity import Singularity
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class PlanFailedOnTrajectoryResponse(BaseModel):
+    """
+    The planning failed. The motion can be executed until the defected command part starts.
+    """  # noqa: E501
+
+    motion: Optional[StrictStr] = Field(default=None, description="Identifier of the motion until the error.")
+    description: Optional[StrictStr] = None
+    last_valid_joint_position: Optional[Joints] = None
+    last_valid_tcp_pose: Optional[Pose] = None
+    error_location_on_trajectory: Optional[Union[StrictFloat, StrictInt]] = Field(
+        default=None,
+        description="Location on the trajectory where the error occurred. The location is defined as a floating point range from 0 to n, where 0 is the start of the trajectory and n is the end of the trajectory. n is the number commands. The decimal places represent the percentage of the defective command.",
+    )
+    joint_limit_exceeded: Optional[JointLimitExceeded] = None
+    singularity: Optional[Singularity] = None
+    safety_zone_violation: Optional[SafetyZoneViolation] = None
+    out_of_workspace: Optional[OutOfWorkspace] = None
+    __properties: ClassVar[List[str]] = [
+        "motion",
+        "description",
+        "last_valid_joint_position",
+        "last_valid_tcp_pose",
+        "error_location_on_trajectory",
+        "joint_limit_exceeded",
+        "singularity",
+        "safety_zone_violation",
+        "out_of_workspace",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of PlanFailedOnTrajectoryResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of last_valid_joint_position
+        if self.last_valid_joint_position:
+            _dict["last_valid_joint_position"] = self.last_valid_joint_position.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of last_valid_tcp_pose
+        if self.last_valid_tcp_pose:
+            _dict["last_valid_tcp_pose"] = self.last_valid_tcp_pose.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of joint_limit_exceeded
+        if self.joint_limit_exceeded:
+            _dict["joint_limit_exceeded"] = self.joint_limit_exceeded.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of singularity
+        if self.singularity:
+            _dict["singularity"] = self.singularity.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of safety_zone_violation
+        if self.safety_zone_violation:
+            _dict["safety_zone_violation"] = self.safety_zone_violation.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of out_of_workspace
+        if self.out_of_workspace:
+            _dict["out_of_workspace"] = self.out_of_workspace.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PlanFailedOnTrajectoryResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "motion": obj.get("motion"),
+                "description": obj.get("description"),
+                "last_valid_joint_position": Joints.from_dict(obj["last_valid_joint_position"])
+                if obj.get("last_valid_joint_position") is not None
+                else None,
+                "last_valid_tcp_pose": Pose.from_dict(obj["last_valid_tcp_pose"]) if obj.get("last_valid_tcp_pose") is not None else None,
+                "error_location_on_trajectory": obj.get("error_location_on_trajectory"),
+                "joint_limit_exceeded": JointLimitExceeded.from_dict(obj["joint_limit_exceeded"])
+                if obj.get("joint_limit_exceeded") is not None
+                else None,
+                "singularity": Singularity.from_dict(obj["singularity"]) if obj.get("singularity") is not None else None,
+                "safety_zone_violation": SafetyZoneViolation.from_dict(obj["safety_zone_violation"])
+                if obj.get("safety_zone_violation") is not None
+                else None,
+                "out_of_workspace": OutOfWorkspace.from_dict(obj["out_of_workspace"]) if obj.get("out_of_workspace") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/plan_failed_response.py

@@ -0,0 +1,136 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.joint_limit_exceeded import JointLimitExceeded
+from wandelbots_api_client.models.out_of_workspace import OutOfWorkspace
+from wandelbots_api_client.models.safety_zone_violation import SafetyZoneViolation
+from wandelbots_api_client.models.singularity import Singularity
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class PlanFailedResponse(BaseModel):
+    """
+    Starting point of motion is invalid. Therefore, planning a motion is not possible.
+    """  # noqa: E501
+
+    description: Optional[StrictStr] = None
+    start_joints_missing: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Error in case no start joint position was provided. Every motion needs to start with a joint position as reference to uniquely define the kinematic configuration of the motion-group at the start the motion.",
+    )
+    commands_missing: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Error in case no motion commands were provided. Every planning needs to have at least one motion command to describe the path to be followed.",
+    )
+    joint_limit_exceeded: Optional[JointLimitExceeded] = None
+    singularity: Optional[Singularity] = None
+    safety_zone_violation: Optional[SafetyZoneViolation] = None
+    out_of_workspace: Optional[OutOfWorkspace] = None
+    __properties: ClassVar[List[str]] = [
+        "description",
+        "start_joints_missing",
+        "commands_missing",
+        "joint_limit_exceeded",
+        "singularity",
+        "safety_zone_violation",
+        "out_of_workspace",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of PlanFailedResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of joint_limit_exceeded
+        if self.joint_limit_exceeded:
+            _dict["joint_limit_exceeded"] = self.joint_limit_exceeded.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of singularity
+        if self.singularity:
+            _dict["singularity"] = self.singularity.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of safety_zone_violation
+        if self.safety_zone_violation:
+            _dict["safety_zone_violation"] = self.safety_zone_violation.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of out_of_workspace
+        if self.out_of_workspace:
+            _dict["out_of_workspace"] = self.out_of_workspace.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PlanFailedResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "description": obj.get("description"),
+                "start_joints_missing": obj.get("start_joints_missing"),
+                "commands_missing": obj.get("commands_missing"),
+                "joint_limit_exceeded": JointLimitExceeded.from_dict(obj["joint_limit_exceeded"])
+                if obj.get("joint_limit_exceeded") is not None
+                else None,
+                "singularity": Singularity.from_dict(obj["singularity"]) if obj.get("singularity") is not None else None,
+                "safety_zone_violation": SafetyZoneViolation.from_dict(obj["safety_zone_violation"])
+                if obj.get("safety_zone_violation") is not None
+                else None,
+                "out_of_workspace": OutOfWorkspace.from_dict(obj["out_of_workspace"]) if obj.get("out_of_workspace") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/plan_request.py

@@ -0,0 +1,127 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.command import Command
+from wandelbots_api_client.models.joints import Joints
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class PlanRequest(BaseModel):
+    """
+    PlanRequest
+    """  # noqa: E501
+
+    motion_group: StrictStr = Field(description="Identifier of the motion group.")
+    start_joint_position: Joints = Field(
+        description="-| To define a motion the start joints have to be indicated. Cartesian movements will be in the same kinematic configuration as the start joint position until the first joint point-to-point motion. Motions can only be executed if the start joint position is the current joint position of the motion group. To retrieve the current joint position, use the endpoint [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). To move the robot to the start joint position, use the endpoint [streamMoveToTrajectoryViaJointP2P](#/operations/streamMoveToTrajectoryViaJointP2P)."
+    )
+    commands: List[Command] = Field(
+        description="List of motion commands. A command consists of a motion command (line, circle, joint_ptp, cartesian_ptp, cubic_spline) and corresponding settings (blending, limits override)."
+    )
+    tcp: Optional[StrictStr] = Field(default=None, description="Tool identifier. If not set, the current tool is used.")
+    payload: Optional[StrictStr] = Field(default=None, description="Payload identifier. If unset, the currently set payload is used.")
+    __properties: ClassVar[List[str]] = ["motion_group", "start_joint_position", "commands", "tcp", "payload"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of PlanRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of start_joint_position
+        if self.start_joint_position:
+            _dict["start_joint_position"] = self.start_joint_position.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in commands (list)
+        _items = []
+        if self.commands:
+            for _item in self.commands:
+                # >>> Modified from https://github.com/OpenAPITools/openapi-generator/blob/v7.6.0/modules/openapi-generator/src/main/resources/python/model_generic.mustache
+                #     to not drop empty elements in lists
+                if _item is not None:
+                    _items.append(_item.to_dict())
+                # <<< End modification
+            _dict["commands"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PlanRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "motion_group": obj.get("motion_group"),
+                "start_joint_position": Joints.from_dict(obj["start_joint_position"])
+                if obj.get("start_joint_position") is not None
+                else None,
+                "commands": [
+                    # >>> Modified from https://github.com/OpenAPITools/openapi-generator/blob/v7.6.0/modules/openapi-generator/src/main/resources/python/model_generic.mustache
+                    #     to allow dicts in lists
+                    Command.from_dict(_item) if hasattr(Command, "from_dict") else _item
+                    # <<< End modification
+                    for _item in obj["commands"]
+                ]
+                if obj.get("commands") is not None
+                else None,
+                "tcp": obj.get("tcp"),
+                "payload": obj.get("payload"),
+            }
+        )
+        return _obj

wandelbots_api_client/models/plan_response.py

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.plan_failed_on_trajectory_response import PlanFailedOnTrajectoryResponse
+from wandelbots_api_client.models.plan_failed_response import PlanFailedResponse
+from wandelbots_api_client.models.plan_successful_response import PlanSuccessfulResponse
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class PlanResponse(BaseModel):
+    """
+    -| The plan response signals if the planned motion is executable, partially executable, or not executable. If the motion is executable or partially executable, the response contains an unique identifier for the motion and the end joint position. To execute the motion, use this unique identifier in the move endpoints [streamMoveForward](#/operations/streamMoveForward) or [streamMoveBackward](#/operations/streamMoveBackward). To retrieve information about this motion use the identifier [getMotionTrajectory](#/operations/getMotionTrajectory) and [getMotionTrajectorySample](#/operations/getMotionTrajectorySample). Use the end joint position to plan and concatenate the next motion. If an error occurred, the response contains feedback including the reason for failure and the location where the failure occurred.
+    """  # noqa: E501
+
+    plan_successful_response: Optional[PlanSuccessfulResponse] = None
+    plan_failed_on_trajectory_response: Optional[PlanFailedOnTrajectoryResponse] = None
+    plan_failed_response: Optional[PlanFailedResponse] = None
+    __properties: ClassVar[List[str]] = ["plan_successful_response", "plan_failed_on_trajectory_response", "plan_failed_response"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of PlanResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of plan_successful_response
+        if self.plan_successful_response:
+            _dict["plan_successful_response"] = self.plan_successful_response.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of plan_failed_on_trajectory_response
+        if self.plan_failed_on_trajectory_response:
+            _dict["plan_failed_on_trajectory_response"] = self.plan_failed_on_trajectory_response.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of plan_failed_response
+        if self.plan_failed_response:
+            _dict["plan_failed_response"] = self.plan_failed_response.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PlanResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "plan_successful_response": PlanSuccessfulResponse.from_dict(obj["plan_successful_response"])
+                if obj.get("plan_successful_response") is not None
+                else None,
+                "plan_failed_on_trajectory_response": PlanFailedOnTrajectoryResponse.from_dict(obj["plan_failed_on_trajectory_response"])
+                if obj.get("plan_failed_on_trajectory_response") is not None
+                else None,
+                "plan_failed_response": PlanFailedResponse.from_dict(obj["plan_failed_response"])
+                if obj.get("plan_failed_response") is not None
+                else None,
+            }
+        )
+        return _obj