standardbots 2.20241003.28__py3-none-any.whl → 2.20241003.30__py3-none-any.whl

standardbots/auto_generated/models.py

@@ -915,6 +915,8 @@ class GripperKindEnum(Enum):
   """An OnRobot 2FG14 Gripper is connected"""
   Onrobot3Fg15 = "onrobot_3fg15"
   """An OnRobot 3FG15 Gripper is connected"""
+  OnrobotScrewdriver = "onrobot_screwdriver"
+  """An OnRobot Screwdriver is connected"""
   DhAg = "dh_ag"
   """A DH AG Gripper is connected"""
   DhPgc = "dh_pgc"
@@ -1020,6 +1022,213 @@ def parse_on_robot_3_fg_15_control_kind_enum(data: object) -> OnRobot3FG15Contro
 def serialize_on_robot_3_fg_15_control_kind_enum(data: Union[OnRobot3FG15ControlKindEnum, str]) -> object:
   return OnRobot3FG15ControlKindEnum(data).value
 
+class OnRobotGripKindEnum(Enum):
+  Inward = "inward"
+  """Enum Inward = `inward`"""
+  Outward = "outward"
+  """Enum Outward = `outward`"""
+
+def parse_on_robot_grip_kind_enum(data: object) -> OnRobotGripKindEnum:
+  return OnRobotGripKindEnum(data)
+
+def serialize_on_robot_grip_kind_enum(data: Union[OnRobotGripKindEnum, str]) -> object:
+  return OnRobotGripKindEnum(data).value
+
+@dataclass
+class OnRobotScrewdriverConfiguration:
+  """Configuration for OnRobot Screwdriver"""
+  status: Union[int, None] = None
+  error: Union[str, None] = None
+  busy: Union[bool, None] = None
+  additional_results: Union[int, None] = None
+  current_torque: Union[float, None] = None
+  shank_position: Union[float, None] = None
+  torque_angle_gradient: Union[float, None] = None
+  achieved_torque: Union[float, None] = None
+  target_force: Union[float, None] = None
+  target_torque: Union[float, None] = None
+  quick_changer_version: Union[int, None] = None
+  uncalibrated_error: Union[bool, None] = None
+
+  def validate_status(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "status must be of type int for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_error(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "error must be of type str for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_busy(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "busy must be of type bool for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_additional_results(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "additional_results must be of type int for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_current_torque(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "current_torque must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_shank_position(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "shank_position must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_torque_angle_gradient(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "torque_angle_gradient must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_achieved_torque(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "achieved_torque must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_force(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "target_force must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_torque(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "target_torque must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_quick_changer_version(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "quick_changer_version must be of type int for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_uncalibrated_error(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "uncalibrated_error must be of type bool for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_status(self.status)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_error(self.error)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_busy(self.busy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_additional_results(self.additional_results)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_current_torque(self.current_torque)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_shank_position(self.shank_position)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_torque_angle_gradient(self.torque_angle_gradient)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_achieved_torque(self.achieved_torque)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_target_force(self.target_force)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_target_torque(self.target_torque)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_quick_changer_version(self.quick_changer_version)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_uncalibrated_error(self.uncalibrated_error)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_on_robot_screwdriver_configuration(data: object):
+  return OnRobotScrewdriverConfiguration(
+    status=parse_i_32(data["status"]) if "status" in data else None,
+    error=parse_str(data["error"]) if "error" in data else None,
+    busy=parse_bool(data["busy"]) if "busy" in data else None,
+    additional_results=parse_i_32(data["additional_results"]) if "additional_results" in data else None,
+    current_torque=parse_f_64(data["current_torque"]) if "current_torque" in data else None,
+    shank_position=parse_f_64(data["shank_position"]) if "shank_position" in data else None,
+    torque_angle_gradient=parse_f_64(data["torque_angle_gradient"]) if "torque_angle_gradient" in data else None,
+    achieved_torque=parse_f_64(data["achieved_torque"]) if "achieved_torque" in data else None,
+    target_force=parse_f_64(data["target_force"]) if "target_force" in data else None,
+    target_torque=parse_f_64(data["target_torque"]) if "target_torque" in data else None,
+    quick_changer_version=parse_i_32(data["quick_changer_version"]) if "quick_changer_version" in data else None,
+    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data else None,
+  )
+
+def serialize_on_robot_screwdriver_configuration(data: OnRobotScrewdriverConfiguration) -> object:
+  return {
+    "status": None if data.status is None else serialize_i_32(data.status),
+    "error": None if data.error is None else serialize_str(data.error),
+    "busy": None if data.busy is None else serialize_bool(data.busy),
+    "additional_results": None if data.additional_results is None else serialize_i_32(data.additional_results),
+    "current_torque": None if data.current_torque is None else serialize_f_64(data.current_torque),
+    "shank_position": None if data.shank_position is None else serialize_f_64(data.shank_position),
+    "torque_angle_gradient": None if data.torque_angle_gradient is None else serialize_f_64(data.torque_angle_gradient),
+    "achieved_torque": None if data.achieved_torque is None else serialize_f_64(data.achieved_torque),
+    "target_force": None if data.target_force is None else serialize_f_64(data.target_force),
+    "target_torque": None if data.target_torque is None else serialize_f_64(data.target_torque),
+    "quick_changer_version": None if data.quick_changer_version is None else serialize_i_32(data.quick_changer_version),
+    "uncalibrated_error": None if data.uncalibrated_error is None else serialize_bool(data.uncalibrated_error),
+  }
+
 class OrientationKindEnum(Enum):
   Quaternion = "quaternion"
   """Enum Quaternion = `quaternion`"""
@@ -1826,81 +2035,6 @@ def serialize_force_unit(data: ForceUnit) -> object:
     "value": None if data.value is None else serialize_f_64(data.value),
   }
 
-@dataclass
-class GripperConfiguration:
-  """Configuration of gripper, also known as End Effector"""
-  kind: Union[GripperKindEnum, None] = None
-  dh_ag: Union[DHAGGripperConfiguration, None] = None
-  dh_pgc: Union[DHPGCGripperConfiguration, None] = None
-  dh_cgi: Union[DHCGIGripperConfiguration, None] = None
-
-  def validate_kind(self, value: GripperKindEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [False, "kind is required for GripperConfiguration"]
-
-    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
-      return [False, "kind must be of type GripperKindEnum for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_dh_ag(self, value: DHAGGripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, DHAGGripperConfiguration):
-      return [False, "dh_ag must be of type DHAGGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_dh_pgc(self, value: DHPGCGripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, DHPGCGripperConfiguration):
-      return [False, "dh_pgc must be of type DHPGCGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_dh_cgi(self, value: DHCGIGripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, DHCGIGripperConfiguration):
-      return [False, "dh_cgi must be of type DHCGIGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_kind(self.kind)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_ag(self.dh_ag)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_pgc(self.dh_pgc)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_cgi(self.dh_cgi)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_gripper_configuration(data: object):
-  return GripperConfiguration(
-    kind=parse_gripper_kind_enum(data["kind"]) if "kind" in data else None,
-    dh_ag=parse_dhag_gripper_configuration(data["dh_ag"]) if "dh_ag" in data else None,
-    dh_pgc=parse_dhpgc_gripper_configuration(data["dh_pgc"]) if "dh_pgc" in data else None,
-    dh_cgi=parse_dhcgi_gripper_configuration(data["dh_cgi"]) if "dh_cgi" in data else None,
-  )
-
-def serialize_gripper_configuration(data: GripperConfiguration) -> object:
-  return {
-    "kind": serialize_gripper_kind_enum(data.kind),
-    "dh_ag": None if data.dh_ag is None else serialize_dhag_gripper_configuration(data.dh_ag),
-    "dh_pgc": None if data.dh_pgc is None else serialize_dhpgc_gripper_configuration(data.dh_pgc),
-    "dh_cgi": None if data.dh_cgi is None else serialize_dhcgi_gripper_configuration(data.dh_cgi),
-  }
-
 @dataclass
 class IOStateResponse:
   """Response to a query for the current state of I/O."""
@@ -2112,70 +2246,865 @@ def serialize_position(data: Position) -> object:
     "z": None if data.z is None else serialize_f_64(data.z),
   }
 
-PlanesList = List[Plane]
-
-def parse_planes_list(data: object) -> PlanesList:
-  return [parse_plane(item) for item in data]
-
-def serialize_planes_list(data: PlanesList) -> List[object]:
-  return [serialize_plane(item) for item in data]
-
 @dataclass
-class Orientation:
-  """Orientation of an object in 3D space"""
-  kind: Union[OrientationKindEnum, None] = None
-  quaternion: Union[Quaternion, None] = None
-
-  def validate_kind(self, value: OrientationKindEnum) -> Tuple[bool, str]:
+class OnRobot2FG14GripperConfiguration:
+  """Configuration for OnRobot 2FG14 Gripper"""
+  grip_kind: Union[OnRobotGripKindEnum, None] = None
+  grip_detected: Union[bool, None] = None
+  normalized_width_inner: Union[float, None] = None
+  normalized_width_outer: Union[float, None] = None
+  width_inner: Union[float, None] = None
+  min_width_inner: Union[float, None] = None
+  max_width_inner: Union[float, None] = None
+  width_outer: Union[float, None] = None
+  min_width_outer: Union[float, None] = None
+  max_width_outer: Union[float, None] = None
+  force: Union[float, None] = None
+  max_force: Union[float, None] = None
+  finger_mounting_position: Union[float, None] = None
+  finger_offset: Union[float, None] = None
+  finger_angle: Union[float, None] = None
+  finger_length: Union[float, None] = None
+  finger_height: Union[float, None] = None
+  linear_sensor_error: Union[bool, None] = None
+  uncalibrated_error: Union[bool, None] = None
+
+  def validate_grip_kind(self, value: OnRobotGripKindEnum) -> Tuple[bool, str]:
     if value is None:
-      return [False, "kind is required for Orientation"]
+      return [True, ""]
 
-    if not ((isinstance(value, str) and OrientationKindEnum in ['quaternion']) or isinstance(value, OrientationKindEnum)):
-      return [False, "kind must be of type OrientationKindEnum for Orientation, got " + type(value).__name__]
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+      return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_quaternion(self, value: Quaternion) -> Tuple[bool, str]:
+  def validate_grip_detected(self, value: bool) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, Quaternion):
-      return [False, "quaternion must be of type Quaternion for Orientation, got " + type(value).__name__]
+    if not isinstance(value, bool):
+      return [False, "grip_detected must be of type bool for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_kind(self.kind)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_quaternion(self.quaternion)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_orientation(data: object):
-  return Orientation(
-    kind=parse_orientation_kind_enum(data["kind"]) if "kind" in data else None,
-    quaternion=parse_quaternion(data["quaternion"]) if "quaternion" in data else None,
-  )
+  def validate_normalized_width_inner(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
 
-def serialize_orientation(data: Orientation) -> object:
-  return {
-    "kind": serialize_orientation_kind_enum(data.kind),
-    "quaternion": None if data.quaternion is None else serialize_quaternion(data.quaternion),
-  }
+    if not isinstance(value, float):
+      return [False, "normalized_width_inner must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
 
-@dataclass
-class RecoveryStatusResponse:
-  """Recovery status response"""
-  state: Union[RecoveryStateEnum, None] = None
+    return [True, ""]
 
-  def validate_state(self, value: RecoveryStateEnum) -> Tuple[bool, str]:
+  def validate_normalized_width_outer(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and RecoveryStateEnum in ['Success', 'Interrupted', 'NonIdle', 'Braked', 'PlanningFailure', 'ExecutionFailure', 'ControlSystemFailure', 'EStopTriggered', 'GripperFailure', 'OutOfJointLimitsFailure', 'CollisionFailure', 'TorqueCollisionFailure', 'InBoxingPositionFailure', 'PowerBoardCheckFailure', 'MotionPlannerFailure', 'MotionPlannerFailureStartPositionCollision', 'IOFailure', 'InvalidRoutineLoadedFailure', 'InferenceFailure', 'CameraFailure', 'HaasFailure', 'BotmanHeartbeatLost', 'InternalFailure', 'TorqueLimitExceeded', 'StepPlayFailure', 'UnbrakeFailure', 'WeldFailure', 'TriggerFaultFailure']) or isinstance(value, RecoveryStateEnum)):
-      return [False, "state must be of type RecoveryStateEnum for RecoveryStatusResponse, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "normalized_width_outer must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_width_inner(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "width_inner must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_min_width_inner(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "min_width_inner must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_width_inner(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "max_width_inner must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_width_outer(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "width_outer must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_min_width_outer(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "min_width_outer must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_width_outer(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "max_width_outer must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_force(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "force must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_force(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "max_force must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_mounting_position must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_offset(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_offset must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_angle(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_angle must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_length(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_length must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_height(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_height must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_linear_sensor_error(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "linear_sensor_error must be of type bool for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_uncalibrated_error(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "uncalibrated_error must be of type bool for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_grip_kind(self.grip_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_grip_detected(self.grip_detected)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_normalized_width_inner(self.normalized_width_inner)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_normalized_width_outer(self.normalized_width_outer)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_width_inner(self.width_inner)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_min_width_inner(self.min_width_inner)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_width_inner(self.max_width_inner)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_width_outer(self.width_outer)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_min_width_outer(self.min_width_outer)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_width_outer(self.max_width_outer)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_force(self.force)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_force(self.max_force)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_mounting_position(self.finger_mounting_position)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_offset(self.finger_offset)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_angle(self.finger_angle)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_length(self.finger_length)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_height(self.finger_height)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_linear_sensor_error(self.linear_sensor_error)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_uncalibrated_error(self.uncalibrated_error)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_on_robot_2_fg_14_gripper_configuration(data: object):
+  return OnRobot2FG14GripperConfiguration(
+    grip_kind=parse_on_robot_grip_kind_enum(data["grip_kind"]) if "grip_kind" in data else None,
+    grip_detected=parse_bool(data["grip_detected"]) if "grip_detected" in data else None,
+    normalized_width_inner=parse_f_64(data["normalized_width_inner"]) if "normalized_width_inner" in data else None,
+    normalized_width_outer=parse_f_64(data["normalized_width_outer"]) if "normalized_width_outer" in data else None,
+    width_inner=parse_f_64(data["width_inner"]) if "width_inner" in data else None,
+    min_width_inner=parse_f_64(data["min_width_inner"]) if "min_width_inner" in data else None,
+    max_width_inner=parse_f_64(data["max_width_inner"]) if "max_width_inner" in data else None,
+    width_outer=parse_f_64(data["width_outer"]) if "width_outer" in data else None,
+    min_width_outer=parse_f_64(data["min_width_outer"]) if "min_width_outer" in data else None,
+    max_width_outer=parse_f_64(data["max_width_outer"]) if "max_width_outer" in data else None,
+    force=parse_f_64(data["force"]) if "force" in data else None,
+    max_force=parse_f_64(data["max_force"]) if "max_force" in data else None,
+    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
+    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data else None,
+    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data else None,
+    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data else None,
+    finger_height=parse_f_64(data["finger_height"]) if "finger_height" in data else None,
+    linear_sensor_error=parse_bool(data["linear_sensor_error"]) if "linear_sensor_error" in data else None,
+    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data else None,
+  )
+
+def serialize_on_robot_2_fg_14_gripper_configuration(data: OnRobot2FG14GripperConfiguration) -> object:
+  return {
+    "grip_kind": None if data.grip_kind is None else serialize_on_robot_grip_kind_enum(data.grip_kind),
+    "grip_detected": None if data.grip_detected is None else serialize_bool(data.grip_detected),
+    "normalized_width_inner": None if data.normalized_width_inner is None else serialize_f_64(data.normalized_width_inner),
+    "normalized_width_outer": None if data.normalized_width_outer is None else serialize_f_64(data.normalized_width_outer),
+    "width_inner": None if data.width_inner is None else serialize_f_64(data.width_inner),
+    "min_width_inner": None if data.min_width_inner is None else serialize_f_64(data.min_width_inner),
+    "max_width_inner": None if data.max_width_inner is None else serialize_f_64(data.max_width_inner),
+    "width_outer": None if data.width_outer is None else serialize_f_64(data.width_outer),
+    "min_width_outer": None if data.min_width_outer is None else serialize_f_64(data.min_width_outer),
+    "max_width_outer": None if data.max_width_outer is None else serialize_f_64(data.max_width_outer),
+    "force": None if data.force is None else serialize_f_64(data.force),
+    "max_force": None if data.max_force is None else serialize_f_64(data.max_force),
+    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_f_64(data.finger_mounting_position),
+    "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
+    "finger_angle": None if data.finger_angle is None else serialize_f_64(data.finger_angle),
+    "finger_length": None if data.finger_length is None else serialize_f_64(data.finger_length),
+    "finger_height": None if data.finger_height is None else serialize_f_64(data.finger_height),
+    "linear_sensor_error": None if data.linear_sensor_error is None else serialize_bool(data.linear_sensor_error),
+    "uncalibrated_error": None if data.uncalibrated_error is None else serialize_bool(data.uncalibrated_error),
+  }
+
+@dataclass
+class OnRobot2FG7GripperConfiguration:
+  """Configuration for OnRobot 2FG7 Gripper"""
+  grip_kind: Union[OnRobotGripKindEnum, None] = None
+  grip_detected: Union[bool, None] = None
+  normalized_width_inner: Union[float, None] = None
+  normalized_width_outer: Union[float, None] = None
+  width_inner: Union[float, None] = None
+  min_width_inner: Union[float, None] = None
+  max_width_inner: Union[float, None] = None
+  width_outer: Union[float, None] = None
+  min_width_outer: Union[float, None] = None
+  max_width_outer: Union[float, None] = None
+  force: Union[float, None] = None
+  max_force: Union[float, None] = None
+  finger_mounting_position: Union[float, None] = None
+  finger_offset: Union[float, None] = None
+  finger_angle: Union[float, None] = None
+  finger_length: Union[float, None] = None
+  finger_height: Union[float, None] = None
+  linear_sensor_error: Union[bool, None] = None
+  uncalibrated_error: Union[bool, None] = None
+
+  def validate_grip_kind(self, value: OnRobotGripKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+      return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_grip_detected(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "grip_detected must be of type bool for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_normalized_width_inner(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "normalized_width_inner must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_normalized_width_outer(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "normalized_width_outer must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_width_inner(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "width_inner must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_min_width_inner(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "min_width_inner must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_width_inner(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "max_width_inner must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_width_outer(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "width_outer must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_min_width_outer(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "min_width_outer must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_width_outer(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "max_width_outer must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_force(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "force must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_force(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "max_force must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_mounting_position must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_offset(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_offset must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_angle(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_angle must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_length(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_length must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_height(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_height must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_linear_sensor_error(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "linear_sensor_error must be of type bool for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_uncalibrated_error(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "uncalibrated_error must be of type bool for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_grip_kind(self.grip_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_grip_detected(self.grip_detected)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_normalized_width_inner(self.normalized_width_inner)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_normalized_width_outer(self.normalized_width_outer)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_width_inner(self.width_inner)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_min_width_inner(self.min_width_inner)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_width_inner(self.max_width_inner)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_width_outer(self.width_outer)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_min_width_outer(self.min_width_outer)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_width_outer(self.max_width_outer)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_force(self.force)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_force(self.max_force)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_mounting_position(self.finger_mounting_position)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_offset(self.finger_offset)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_angle(self.finger_angle)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_length(self.finger_length)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_height(self.finger_height)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_linear_sensor_error(self.linear_sensor_error)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_uncalibrated_error(self.uncalibrated_error)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_on_robot_2_fg_7_gripper_configuration(data: object):
+  return OnRobot2FG7GripperConfiguration(
+    grip_kind=parse_on_robot_grip_kind_enum(data["grip_kind"]) if "grip_kind" in data else None,
+    grip_detected=parse_bool(data["grip_detected"]) if "grip_detected" in data else None,
+    normalized_width_inner=parse_f_64(data["normalized_width_inner"]) if "normalized_width_inner" in data else None,
+    normalized_width_outer=parse_f_64(data["normalized_width_outer"]) if "normalized_width_outer" in data else None,
+    width_inner=parse_f_64(data["width_inner"]) if "width_inner" in data else None,
+    min_width_inner=parse_f_64(data["min_width_inner"]) if "min_width_inner" in data else None,
+    max_width_inner=parse_f_64(data["max_width_inner"]) if "max_width_inner" in data else None,
+    width_outer=parse_f_64(data["width_outer"]) if "width_outer" in data else None,
+    min_width_outer=parse_f_64(data["min_width_outer"]) if "min_width_outer" in data else None,
+    max_width_outer=parse_f_64(data["max_width_outer"]) if "max_width_outer" in data else None,
+    force=parse_f_64(data["force"]) if "force" in data else None,
+    max_force=parse_f_64(data["max_force"]) if "max_force" in data else None,
+    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
+    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data else None,
+    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data else None,
+    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data else None,
+    finger_height=parse_f_64(data["finger_height"]) if "finger_height" in data else None,
+    linear_sensor_error=parse_bool(data["linear_sensor_error"]) if "linear_sensor_error" in data else None,
+    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data else None,
+  )
+
+def serialize_on_robot_2_fg_7_gripper_configuration(data: OnRobot2FG7GripperConfiguration) -> object:
+  return {
+    "grip_kind": None if data.grip_kind is None else serialize_on_robot_grip_kind_enum(data.grip_kind),
+    "grip_detected": None if data.grip_detected is None else serialize_bool(data.grip_detected),
+    "normalized_width_inner": None if data.normalized_width_inner is None else serialize_f_64(data.normalized_width_inner),
+    "normalized_width_outer": None if data.normalized_width_outer is None else serialize_f_64(data.normalized_width_outer),
+    "width_inner": None if data.width_inner is None else serialize_f_64(data.width_inner),
+    "min_width_inner": None if data.min_width_inner is None else serialize_f_64(data.min_width_inner),
+    "max_width_inner": None if data.max_width_inner is None else serialize_f_64(data.max_width_inner),
+    "width_outer": None if data.width_outer is None else serialize_f_64(data.width_outer),
+    "min_width_outer": None if data.min_width_outer is None else serialize_f_64(data.min_width_outer),
+    "max_width_outer": None if data.max_width_outer is None else serialize_f_64(data.max_width_outer),
+    "force": None if data.force is None else serialize_f_64(data.force),
+    "max_force": None if data.max_force is None else serialize_f_64(data.max_force),
+    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_f_64(data.finger_mounting_position),
+    "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
+    "finger_angle": None if data.finger_angle is None else serialize_f_64(data.finger_angle),
+    "finger_length": None if data.finger_length is None else serialize_f_64(data.finger_length),
+    "finger_height": None if data.finger_height is None else serialize_f_64(data.finger_height),
+    "linear_sensor_error": None if data.linear_sensor_error is None else serialize_bool(data.linear_sensor_error),
+    "uncalibrated_error": None if data.uncalibrated_error is None else serialize_bool(data.uncalibrated_error),
+  }
+
+@dataclass
+class OnRobot3FG15GripperConfiguration:
+  """Configuration for OnRobot 3FG15 Gripper"""
+  grip_detected: Union[bool, None] = None
+  force_grip_detected: Union[bool, None] = None
+  calibration_ok: Union[bool, None] = None
+  diameter: Union[float, None] = None
+  grip_kind: Union[OnRobotGripKindEnum, None] = None
+  finger_angle: Union[float, None] = None
+  force_applied_fraction: Union[float, None] = None
+  force_applied_newtons: Union[float, None] = None
+  target_force_newtons: Union[float, None] = None
+  finger_length: Union[float, None] = None
+  finger_mounting_position: Union[float, None] = None
+  finger_offset: Union[float, None] = None
+
+  def validate_grip_detected(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "grip_detected must be of type bool for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_force_grip_detected(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "force_grip_detected must be of type bool for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_calibration_ok(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "calibration_ok must be of type bool for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_diameter(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "diameter must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_grip_kind(self, value: OnRobotGripKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+      return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_angle(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_angle must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_force_applied_fraction(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "force_applied_fraction must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_force_applied_newtons(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "force_applied_newtons must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_force_newtons(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "target_force_newtons must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_length(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_length must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_mounting_position must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_finger_offset(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "finger_offset must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_grip_detected(self.grip_detected)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_force_grip_detected(self.force_grip_detected)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_calibration_ok(self.calibration_ok)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_diameter(self.diameter)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_grip_kind(self.grip_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_angle(self.finger_angle)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_force_applied_fraction(self.force_applied_fraction)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_force_applied_newtons(self.force_applied_newtons)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_target_force_newtons(self.target_force_newtons)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_length(self.finger_length)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_mounting_position(self.finger_mounting_position)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_finger_offset(self.finger_offset)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_on_robot_3_fg_15_gripper_configuration(data: object):
+  return OnRobot3FG15GripperConfiguration(
+    grip_detected=parse_bool(data["grip_detected"]) if "grip_detected" in data else None,
+    force_grip_detected=parse_bool(data["force_grip_detected"]) if "force_grip_detected" in data else None,
+    calibration_ok=parse_bool(data["calibration_ok"]) if "calibration_ok" in data else None,
+    diameter=parse_f_64(data["diameter"]) if "diameter" in data else None,
+    grip_kind=parse_on_robot_grip_kind_enum(data["grip_kind"]) if "grip_kind" in data else None,
+    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data else None,
+    force_applied_fraction=parse_f_64(data["force_applied_fraction"]) if "force_applied_fraction" in data else None,
+    force_applied_newtons=parse_f_64(data["force_applied_newtons"]) if "force_applied_newtons" in data else None,
+    target_force_newtons=parse_f_64(data["target_force_newtons"]) if "target_force_newtons" in data else None,
+    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data else None,
+    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
+    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data else None,
+  )
+
+def serialize_on_robot_3_fg_15_gripper_configuration(data: OnRobot3FG15GripperConfiguration) -> object:
+  return {
+    "grip_detected": None if data.grip_detected is None else serialize_bool(data.grip_detected),
+    "force_grip_detected": None if data.force_grip_detected is None else serialize_bool(data.force_grip_detected),
+    "calibration_ok": None if data.calibration_ok is None else serialize_bool(data.calibration_ok),
+    "diameter": None if data.diameter is None else serialize_f_64(data.diameter),
+    "grip_kind": None if data.grip_kind is None else serialize_on_robot_grip_kind_enum(data.grip_kind),
+    "finger_angle": None if data.finger_angle is None else serialize_f_64(data.finger_angle),
+    "force_applied_fraction": None if data.force_applied_fraction is None else serialize_f_64(data.force_applied_fraction),
+    "force_applied_newtons": None if data.force_applied_newtons is None else serialize_f_64(data.force_applied_newtons),
+    "target_force_newtons": None if data.target_force_newtons is None else serialize_f_64(data.target_force_newtons),
+    "finger_length": None if data.finger_length is None else serialize_f_64(data.finger_length),
+    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_f_64(data.finger_mounting_position),
+    "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
+  }
+
+PlanesList = List[Plane]
+
+def parse_planes_list(data: object) -> PlanesList:
+  return [parse_plane(item) for item in data]
+
+def serialize_planes_list(data: PlanesList) -> List[object]:
+  return [serialize_plane(item) for item in data]
+
+@dataclass
+class Orientation:
+  """Orientation of an object in 3D space"""
+  kind: Union[OrientationKindEnum, None] = None
+  quaternion: Union[Quaternion, None] = None
+
+  def validate_kind(self, value: OrientationKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "kind is required for Orientation"]
+
+    if not ((isinstance(value, str) and OrientationKindEnum in ['quaternion']) or isinstance(value, OrientationKindEnum)):
+      return [False, "kind must be of type OrientationKindEnum for Orientation, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_quaternion(self, value: Quaternion) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, Quaternion):
+      return [False, "quaternion must be of type Quaternion for Orientation, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_kind(self.kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_quaternion(self.quaternion)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_orientation(data: object):
+  return Orientation(
+    kind=parse_orientation_kind_enum(data["kind"]) if "kind" in data else None,
+    quaternion=parse_quaternion(data["quaternion"]) if "quaternion" in data else None,
+  )
+
+def serialize_orientation(data: Orientation) -> object:
+  return {
+    "kind": serialize_orientation_kind_enum(data.kind),
+    "quaternion": None if data.quaternion is None else serialize_quaternion(data.quaternion),
+  }
+
+@dataclass
+class RecoveryStatusResponse:
+  """Recovery status response"""
+  state: Union[RecoveryStateEnum, None] = None
+
+  def validate_state(self, value: RecoveryStateEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RecoveryStateEnum in ['Success', 'Interrupted', 'NonIdle', 'Braked', 'PlanningFailure', 'ExecutionFailure', 'ControlSystemFailure', 'EStopTriggered', 'GripperFailure', 'OutOfJointLimitsFailure', 'CollisionFailure', 'TorqueCollisionFailure', 'InBoxingPositionFailure', 'PowerBoardCheckFailure', 'MotionPlannerFailure', 'MotionPlannerFailureStartPositionCollision', 'IOFailure', 'InvalidRoutineLoadedFailure', 'InferenceFailure', 'CameraFailure', 'HaasFailure', 'BotmanHeartbeatLost', 'InternalFailure', 'TorqueLimitExceeded', 'StepPlayFailure', 'UnbrakeFailure', 'WeldFailure', 'TriggerFaultFailure']) or isinstance(value, RecoveryStateEnum)):
+      return [False, "state must be of type RecoveryStateEnum for RecoveryStatusResponse, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -2883,6 +3812,141 @@ def serialize_schunk_e_gx_gripper_command_request(data: SchunkEGxGripperCommandR
     "control_kind": serialize_schunk_e_gx_control_kind_enum(data.control_kind),
   }
 
+@dataclass
+class GripperConfiguration:
+  """Configuration of gripper, also known as End Effector"""
+  kind: Union[GripperKindEnum, None] = None
+  onrobot_2fg7: Union[OnRobot2FG7GripperConfiguration, None] = None
+  onrobot_2fg14: Union[OnRobot2FG14GripperConfiguration, None] = None
+  onrobot_3fg15: Union[OnRobot3FG15GripperConfiguration, None] = None
+  onrobot_screwdriver: Union[OnRobotScrewdriverConfiguration, None] = None
+  dh_ag: Union[DHAGGripperConfiguration, None] = None
+  dh_pgc: Union[DHPGCGripperConfiguration, None] = None
+  dh_cgi: Union[DHCGIGripperConfiguration, None] = None
+
+  def validate_kind(self, value: GripperKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "kind is required for GripperConfiguration"]
+
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'onrobot_screwdriver', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
+      return [False, "kind must be of type GripperKindEnum for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_onrobot_2fg7(self, value: OnRobot2FG7GripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, OnRobot2FG7GripperConfiguration):
+      return [False, "onrobot_2fg7 must be of type OnRobot2FG7GripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_onrobot_2fg14(self, value: OnRobot2FG14GripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, OnRobot2FG14GripperConfiguration):
+      return [False, "onrobot_2fg14 must be of type OnRobot2FG14GripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_onrobot_3fg15(self, value: OnRobot3FG15GripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, OnRobot3FG15GripperConfiguration):
+      return [False, "onrobot_3fg15 must be of type OnRobot3FG15GripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_onrobot_screwdriver(self, value: OnRobotScrewdriverConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, OnRobotScrewdriverConfiguration):
+      return [False, "onrobot_screwdriver must be of type OnRobotScrewdriverConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_dh_ag(self, value: DHAGGripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHAGGripperConfiguration):
+      return [False, "dh_ag must be of type DHAGGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_dh_pgc(self, value: DHPGCGripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHPGCGripperConfiguration):
+      return [False, "dh_pgc must be of type DHPGCGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_dh_cgi(self, value: DHCGIGripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHCGIGripperConfiguration):
+      return [False, "dh_cgi must be of type DHCGIGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_kind(self.kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_onrobot_2fg7(self.onrobot_2fg7)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_onrobot_2fg14(self.onrobot_2fg14)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_onrobot_3fg15(self.onrobot_3fg15)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_onrobot_screwdriver(self.onrobot_screwdriver)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_ag(self.dh_ag)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_pgc(self.dh_pgc)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_cgi(self.dh_cgi)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_gripper_configuration(data: object):
+  return GripperConfiguration(
+    kind=parse_gripper_kind_enum(data["kind"]) if "kind" in data else None,
+    onrobot_2fg7=parse_on_robot_2_fg_7_gripper_configuration(data["onrobot_2fg7"]) if "onrobot_2fg7" in data else None,
+    onrobot_2fg14=parse_on_robot_2_fg_14_gripper_configuration(data["onrobot_2fg14"]) if "onrobot_2fg14" in data else None,
+    onrobot_3fg15=parse_on_robot_3_fg_15_gripper_configuration(data["onrobot_3fg15"]) if "onrobot_3fg15" in data else None,
+    onrobot_screwdriver=parse_on_robot_screwdriver_configuration(data["onrobot_screwdriver"]) if "onrobot_screwdriver" in data else None,
+    dh_ag=parse_dhag_gripper_configuration(data["dh_ag"]) if "dh_ag" in data else None,
+    dh_pgc=parse_dhpgc_gripper_configuration(data["dh_pgc"]) if "dh_pgc" in data else None,
+    dh_cgi=parse_dhcgi_gripper_configuration(data["dh_cgi"]) if "dh_cgi" in data else None,
+  )
+
+def serialize_gripper_configuration(data: GripperConfiguration) -> object:
+  return {
+    "kind": serialize_gripper_kind_enum(data.kind),
+    "onrobot_2fg7": None if data.onrobot_2fg7 is None else serialize_on_robot_2_fg_7_gripper_configuration(data.onrobot_2fg7),
+    "onrobot_2fg14": None if data.onrobot_2fg14 is None else serialize_on_robot_2_fg_14_gripper_configuration(data.onrobot_2fg14),
+    "onrobot_3fg15": None if data.onrobot_3fg15 is None else serialize_on_robot_3_fg_15_gripper_configuration(data.onrobot_3fg15),
+    "onrobot_screwdriver": None if data.onrobot_screwdriver is None else serialize_on_robot_screwdriver_configuration(data.onrobot_screwdriver),
+    "dh_ag": None if data.dh_ag is None else serialize_dhag_gripper_configuration(data.dh_ag),
+    "dh_pgc": None if data.dh_pgc is None else serialize_dhpgc_gripper_configuration(data.dh_pgc),
+    "dh_cgi": None if data.dh_cgi is None else serialize_dhcgi_gripper_configuration(data.dh_cgi),
+  }
+
 @dataclass
 class PlanesPaginatedResponse:
   """Paginated response containing plane data"""
@@ -3074,7 +4138,7 @@ class GripperCommandRequest:
     if value is None:
       return [False, "kind is required for GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'onrobot_screwdriver', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]