standardbots 2.20241120.1__py3-none-any.whl → 2.20250128.1__py3-none-any.whl

standardbots/auto_generated/models.py

@@ -224,6 +224,81 @@ def parse_arm_position_update_request_response_kind_enum(data: object) -> ArmPos
 def serialize_arm_position_update_request_response_kind_enum(data: Union[ArmPositionUpdateRequestResponseKindEnum, str]) -> object:
   return ArmPositionUpdateRequestResponseKindEnum(data).value
 
+@dataclass
+class BotIdentityData:
+  """Data about the robot's identity"""
+  robotId: Union[str, None] = None
+  alias: Union[str, None] = None
+  robotOperationMode: Union[str, None] = None
+  applicationUrl: Union[str, None] = None
+
+  def validate_robotId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "robotId must be of type str for BotIdentityData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_alias(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "alias must be of type str for BotIdentityData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_robotOperationMode(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "robotOperationMode must be of type str for BotIdentityData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_applicationUrl(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "applicationUrl must be of type str for BotIdentityData, 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_robotId(self.robotId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_alias(self.alias)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotOperationMode(self.robotOperationMode)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_applicationUrl(self.applicationUrl)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_bot_identity_data(data: object):
+  return BotIdentityData(
+    robotId=parse_str(data["robotId"]) if "robotId" in data and data.get("robotId") is not None else None,
+    alias=parse_str(data["alias"]) if "alias" in data and data.get("alias") is not None else None,
+    robotOperationMode=parse_str(data["robotOperationMode"]) if "robotOperationMode" in data and data.get("robotOperationMode") is not None else None,
+    applicationUrl=parse_str(data["applicationUrl"]) if "applicationUrl" in data and data.get("applicationUrl") is not None else None,
+  )
+
+def serialize_bot_identity_data(data: BotIdentityData) -> object:
+  return {
+    "robotId": None if data.robotId is None else serialize_str(data.robotId),
+    "alias": None if data.alias is None else serialize_str(data.alias),
+    "robotOperationMode": None if data.robotOperationMode is None else serialize_str(data.robotOperationMode),
+    "applicationUrl": None if data.applicationUrl is None else serialize_str(data.applicationUrl),
+  }
+
 class BrakesStateEnum(Enum):
   Engaged = "engaged"
   """Robot Brakes are engaged, robot is not able to move"""
@@ -1012,6 +1087,8 @@ class ErrorEnum(Enum):
   """Requested resource not found"""
   InvalidSpaceSpecified = "invalid_space_specified"
   """Space specified was invalid or not found"""
+  InvalidParameters = "invalid_parameters"
+  """Parameters are invalid"""
 
 def parse_error_enum(data: object) -> ErrorEnum:
   return ErrorEnum(data)
@@ -1125,6 +1202,14 @@ def serialize_euler_pose(data: EulerPose) -> object:
     "rz": None if data.rz is None else serialize_f_64(data.rz),
   }
 
+FloatList = List[float]
+
+def parse_float_list(data: object) -> FloatList:
+  return [parse_f_64(item) for item in data]
+
+def serialize_float_list(data: FloatList) -> List[object]:
+  return [serialize_f_64(item) for item in data]
+
 class ForceUnitKind(Enum):
   Newtons = "newtons"
   """Enum Newtons = `newtons`"""
@@ -1144,6 +1229,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"
@@ -1295,6 +1382,66 @@ def parse_joint_rotations(data: object) -> JointRotations:
 def serialize_joint_rotations(data: JointRotations) -> object:
   return [serialize_f_64(data[0]),serialize_f_64(data[1]),serialize_f_64(data[2]),serialize_f_64(data[3]),serialize_f_64(data[4]),serialize_f_64(data[5]),]
 
+@dataclass
+class JointStateDisturbance:
+  """Disturbance of a joint"""
+  disturbance: Union[float, None] = None
+  amperageDisturbance: Union[float, None] = None
+  windupDisturbance: Union[float, None] = None
+
+  def validate_disturbance(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "disturbance must be of type float for JointStateDisturbance, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_amperageDisturbance(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "amperageDisturbance must be of type float for JointStateDisturbance, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_windupDisturbance(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "windupDisturbance must be of type float for JointStateDisturbance, 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_disturbance(self.disturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_amperageDisturbance(self.amperageDisturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_windupDisturbance(self.windupDisturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_joint_state_disturbance(data: object):
+  return JointStateDisturbance(
+    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None else None,
+    amperageDisturbance=parse_f_64(data["amperageDisturbance"]) if "amperageDisturbance" in data and data.get("amperageDisturbance") is not None else None,
+    windupDisturbance=parse_f_64(data["windupDisturbance"]) if "windupDisturbance" in data and data.get("windupDisturbance") is not None else None,
+  )
+
+def serialize_joint_state_disturbance(data: JointStateDisturbance) -> object:
+  return {
+    "disturbance": None if data.disturbance is None else serialize_f_64(data.disturbance),
+    "amperageDisturbance": None if data.amperageDisturbance is None else serialize_f_64(data.amperageDisturbance),
+    "windupDisturbance": None if data.windupDisturbance is None else serialize_f_64(data.windupDisturbance),
+  }
+
 class LinearGripDirectionEnum(Enum):
   Inward = "inward"
   """Move gripper inward to grip. Measure grip position based on interior of gripper fingers and exterior of object"""
@@ -1391,6 +1538,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 and data.get("status") is not None else None,
+    error=parse_str(data["error"]) if "error" in data and data.get("error") is not None else None,
+    busy=parse_bool(data["busy"]) if "busy" in data and data.get("busy") is not None else None,
+    additional_results=parse_i_32(data["additional_results"]) if "additional_results" in data and data.get("additional_results") is not None else None,
+    current_torque=parse_f_64(data["current_torque"]) if "current_torque" in data and data.get("current_torque") is not None else None,
+    shank_position=parse_f_64(data["shank_position"]) if "shank_position" in data and data.get("shank_position") is not None else None,
+    torque_angle_gradient=parse_f_64(data["torque_angle_gradient"]) if "torque_angle_gradient" in data and data.get("torque_angle_gradient") is not None else None,
+    achieved_torque=parse_f_64(data["achieved_torque"]) if "achieved_torque" in data and data.get("achieved_torque") is not None else None,
+    target_force=parse_f_64(data["target_force"]) if "target_force" in data and data.get("target_force") is not None else None,
+    target_torque=parse_f_64(data["target_torque"]) if "target_torque" in data and data.get("target_torque") is not None else None,
+    quick_changer_version=parse_i_32(data["quick_changer_version"]) if "quick_changer_version" in data and data.get("quick_changer_version") is not None else None,
+    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data and data.get("uncalibrated_error") is not None 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`"""
@@ -1732,70 +2086,6 @@ def serialize_quaternion(data: Quaternion) -> object:
     "w": None if data.w is None else serialize_f_64(data.w),
   }
 
-class RecoveryStateEnum(Enum):
-  Success = "Success"
-  """Enum Success = `Success`"""
-  Interrupted = "Interrupted"
-  """Enum Interrupted = `Interrupted`"""
-  NonIdle = "NonIdle"
-  """Enum NonIdle = `NonIdle`"""
-  Braked = "Braked"
-  """Enum Braked = `Braked`"""
-  PlanningFailure = "PlanningFailure"
-  """Enum PlanningFailure = `PlanningFailure`"""
-  ExecutionFailure = "ExecutionFailure"
-  """Enum ExecutionFailure = `ExecutionFailure`"""
-  ControlSystemFailure = "ControlSystemFailure"
-  """Enum ControlSystemFailure = `ControlSystemFailure`"""
-  EStopTriggered = "EStopTriggered"
-  """Enum EStopTriggered = `EStopTriggered`"""
-  GripperFailure = "GripperFailure"
-  """Enum GripperFailure = `GripperFailure`"""
-  OutOfJointLimitsFailure = "OutOfJointLimitsFailure"
-  """Enum OutOfJointLimitsFailure = `OutOfJointLimitsFailure`"""
-  CollisionFailure = "CollisionFailure"
-  """Enum CollisionFailure = `CollisionFailure`"""
-  TorqueCollisionFailure = "TorqueCollisionFailure"
-  """Enum TorqueCollisionFailure = `TorqueCollisionFailure`"""
-  InBoxingPositionFailure = "InBoxingPositionFailure"
-  """Enum InBoxingPositionFailure = `InBoxingPositionFailure`"""
-  PowerBoardCheckFailure = "PowerBoardCheckFailure"
-  """Enum PowerBoardCheckFailure = `PowerBoardCheckFailure`"""
-  MotionPlannerFailure = "MotionPlannerFailure"
-  """Enum MotionPlannerFailure = `MotionPlannerFailure`"""
-  MotionPlannerFailureStartPositionCollision = "MotionPlannerFailureStartPositionCollision"
-  """Enum MotionPlannerFailureStartPositionCollision = `MotionPlannerFailureStartPositionCollision`"""
-  IOFailure = "IOFailure"
-  """Enum IOFailure = `IOFailure`"""
-  InvalidRoutineLoadedFailure = "InvalidRoutineLoadedFailure"
-  """Enum InvalidRoutineLoadedFailure = `InvalidRoutineLoadedFailure`"""
-  InferenceFailure = "InferenceFailure"
-  """Enum InferenceFailure = `InferenceFailure`"""
-  CameraFailure = "CameraFailure"
-  """Enum CameraFailure = `CameraFailure`"""
-  HaasFailure = "HaasFailure"
-  """Enum HaasFailure = `HaasFailure`"""
-  BotmanHeartbeatLost = "BotmanHeartbeatLost"
-  """Enum BotmanHeartbeatLost = `BotmanHeartbeatLost`"""
-  InternalFailure = "InternalFailure"
-  """Enum InternalFailure = `InternalFailure`"""
-  TorqueLimitExceeded = "TorqueLimitExceeded"
-  """Enum TorqueLimitExceeded = `TorqueLimitExceeded`"""
-  StepPlayFailure = "StepPlayFailure"
-  """Enum StepPlayFailure = `StepPlayFailure`"""
-  UnbrakeFailure = "UnbrakeFailure"
-  """Enum UnbrakeFailure = `UnbrakeFailure`"""
-  WeldFailure = "WeldFailure"
-  """Enum WeldFailure = `WeldFailure`"""
-  TriggerFaultFailure = "TriggerFaultFailure"
-  """Enum TriggerFaultFailure = `TriggerFaultFailure`"""
-
-def parse_recovery_state_enum(data: object) -> RecoveryStateEnum:
-  return RecoveryStateEnum(data)
-
-def serialize_recovery_state_enum(data: Union[RecoveryStateEnum, str]) -> object:
-  return RecoveryStateEnum(data).value
-
 class RecoveryTypeEnum(Enum):
   Recoverable = "Recoverable"
   """Enum Recoverable = `Recoverable`"""
@@ -1826,6 +2116,28 @@ def parse_robot_control_mode_enum(data: object) -> RobotControlModeEnum:
 def serialize_robot_control_mode_enum(data: Union[RobotControlModeEnum, str]) -> object:
   return RobotControlModeEnum(data).value
 
+class RobotStatusEnum(Enum):
+  Idle = "Idle"
+  """Enum Idle = `Idle`"""
+  RunningAdHocCommand = "RunningAdHocCommand"
+  """Enum RunningAdHocCommand = `RunningAdHocCommand`"""
+  RoutineRunning = "RoutineRunning"
+  """Enum RoutineRunning = `RoutineRunning`"""
+  Antigravity = "Antigravity"
+  """Enum Antigravity = `Antigravity`"""
+  AntigravitySlow = "AntigravitySlow"
+  """Enum AntigravitySlow = `AntigravitySlow`"""
+  Failure = "Failure"
+  """Enum Failure = `Failure`"""
+  Recovering = "Recovering"
+  """Enum Recovering = `Recovering`"""
+
+def parse_robot_status_enum(data: object) -> RobotStatusEnum:
+  return RobotStatusEnum(data)
+
+def serialize_robot_status_enum(data: Union[RobotStatusEnum, str]) -> object:
+  return RobotStatusEnum(data).value
+
 class ROSControlStateEnum(Enum):
   Enabled = "enabled"
   """ROS control is enabled."""
@@ -2413,7 +2725,7 @@ def serialize_camera_intrinsics_response(data: CameraIntrinsicsResponse) -> obje
 
 @dataclass
 class CameraFrameRequest:
-  """Request for a single camera frame."""
+  """Request for a single camera frame. In JPEG format."""
   camera_settings: Union[CameraSettings, None] = None
 
   def validate_camera_settings(self, value: CameraSettings) -> Tuple[bool, str]:
@@ -2717,105 +3029,30 @@ def serialize_tooltip_position_response(data: TooltipPositionResponse) -> object
     "pose": None if data.pose is None else serialize_cartesian_pose(data.pose),
   }
 
-@dataclass
-class JointState:
-  """State of a joint"""
-  braked: Union[bool, None] = None
-  connectionStatus: Union[ConnectionStatus, None] = None
-  inCollision: Union[bool, None] = None
-  disturbance: Union[float, None] = None
+EnvironmentVariablesList = List[EnvironmentVariable]
 
-  def validate_braked(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
+  return [parse_environment_variable(item) for item in data]
 
-    if not isinstance(value, bool):
-      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
+def serialize_environment_variables_list(data: EnvironmentVariablesList) -> List[object]:
+  return [serialize_environment_variable(item) for item in data]
 
-    return [True, ""]
+@dataclass
+class ErrorResponse:
+  """Error Response"""
+  error: Union[ErrorEnum, None] = None
+  message: Union[str, None] = None
 
-  def validate_connectionStatus(self, value: ConnectionStatus) -> Tuple[bool, str]:
+  def validate_error(self, value: ErrorEnum) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "error is required for ErrorResponse"]
 
-    if not ((isinstance(value, str) and ConnectionStatus in ['connected', 'disconnected', 'ready']) or isinstance(value, ConnectionStatus)):
-      return [False, "connectionStatus must be of type ConnectionStatus for JointState, got " + type(value).__name__]
+    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'robot_not_idle', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'recovery_error', 'not_found', 'invalid_space_specified', 'invalid_parameters']) or isinstance(value, ErrorEnum)):
+      return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_inCollision(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, bool):
-      return [False, "inCollision must be of type bool for JointState, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_disturbance(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "disturbance must be of type float for JointState, 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_braked(self.braked)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_connectionStatus(self.connectionStatus)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_inCollision(self.inCollision)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_disturbance(self.disturbance)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_joint_state(data: object):
-  return JointState(
-    braked=parse_bool(data["braked"]) if "braked" in data and data.get("braked") is not None else None,
-    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data and data.get("connectionStatus") is not None else None,
-    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data and data.get("inCollision") is not None else None,
-    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None else None,
-  )
-
-def serialize_joint_state(data: JointState) -> object:
-  return {
-    "braked": None if data.braked is None else serialize_bool(data.braked),
-    "connectionStatus": None if data.connectionStatus is None else serialize_connection_status(data.connectionStatus),
-    "inCollision": None if data.inCollision is None else serialize_bool(data.inCollision),
-    "disturbance": None if data.disturbance is None else serialize_f_64(data.disturbance),
-  }
-
-EnvironmentVariablesList = List[EnvironmentVariable]
-
-def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
-  return [parse_environment_variable(item) for item in data]
-
-def serialize_environment_variables_list(data: EnvironmentVariablesList) -> List[object]:
-  return [serialize_environment_variable(item) for item in data]
-
-@dataclass
-class ErrorResponse:
-  """Error Response"""
-  error: Union[ErrorEnum, None] = None
-  message: Union[str, None] = None
-
-  def validate_error(self, value: ErrorEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [False, "error is required for ErrorResponse"]
-
-    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'robot_not_idle', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'recovery_error', 'not_found', 'invalid_space_specified']) or isinstance(value, ErrorEnum)):
-      return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_message(self, value: str) -> Tuple[bool, str]:
+  def validate_message(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [False, "message is required for ErrorResponse"]
 
@@ -2907,124 +3144,244 @@ def serialize_cartesian_pose_request(data: CartesianPoseRequest) -> object:
   }
 
 @dataclass
-class ForceUnit:
-  """Reusable Abstraction for force units (eg force, torque)
-"""
-  unit_kind: Union[ForceUnitKind, None] = None
-  value: Union[float, None] = None
+class URDFParameters:
+  """The URDF parameters for the robot"""
+  joint0_xyz: Union[FloatList, None] = None
+  joint0_rpy: Union[FloatList, None] = None
+  joint1_xyz: Union[FloatList, None] = None
+  joint1_rpy: Union[FloatList, None] = None
+  joint2_xyz: Union[FloatList, None] = None
+  joint2_rpy: Union[FloatList, None] = None
+  joint3_xyz: Union[FloatList, None] = None
+  joint3_rpy: Union[FloatList, None] = None
+  joint4_xyz: Union[FloatList, None] = None
+  joint4_rpy: Union[FloatList, None] = None
+  joint5_xyz: Union[FloatList, None] = None
+  joint5_rpy: Union[FloatList, None] = None
+
+  def validate_joint0_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint0_xyz is required for URDFParameters"]
 
-  def validate_unit_kind(self, value: ForceUnitKind) -> Tuple[bool, str]:
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint0_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint0_rpy(self, value: FloatList) -> Tuple[bool, str]:
     if value is None:
-      return [False, "unit_kind is required for ForceUnit"]
+      return [False, "joint0_rpy is required for URDFParameters"]
 
-    if not ((isinstance(value, str) and ForceUnitKind in ['newtons', 'pounds']) or isinstance(value, ForceUnitKind)):
-      return [False, "unit_kind must be of type ForceUnitKind for ForceUnit, got " + type(value).__name__]
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint0_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_value(self, value: float) -> Tuple[bool, str]:
+  def validate_joint1_xyz(self, value: FloatList) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "joint1_xyz is required for URDFParameters"]
 
-    if not isinstance(value, float):
-      return [False, "value must be of type float for ForceUnit, got " + type(value).__name__]
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint1_xyz must be of type FloatList for URDFParameters, 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_unit_kind(self.unit_kind)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_value(self.value)
-    if not is_valid:
-      raise TypeError(error_str)
+  def validate_joint1_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint1_rpy is required for URDFParameters"]
 
-def parse_force_unit(data: object):
-  return ForceUnit(
-    unit_kind=parse_force_unit_kind(data["unit_kind"]) if "unit_kind" in data and data.get("unit_kind") is not None else None,
-    value=parse_f_64(data["value"]) if "value" in data and data.get("value") is not None else None,
-  )
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint1_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
 
-def serialize_force_unit(data: ForceUnit) -> object:
-  return {
-    "unit_kind": serialize_force_unit_kind(data.unit_kind),
-    "value": None if data.value is None else serialize_f_64(data.value),
-  }
+    return [True, ""]
 
-@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_joint2_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint2_xyz is required for URDFParameters"]
 
-  def validate_kind(self, value: GripperKindEnum) -> Tuple[bool, str]:
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint2_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint2_rpy(self, value: FloatList) -> Tuple[bool, str]:
     if value is None:
-      return [False, "kind is required for GripperConfiguration"]
+      return [False, "joint2_rpy is required for URDFParameters"]
 
-    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__]
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint2_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_dh_ag(self, value: DHAGGripperConfiguration) -> Tuple[bool, str]:
+  def validate_joint3_xyz(self, value: FloatList) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "joint3_xyz is required for URDFParameters"]
 
-    if not isinstance(value, DHAGGripperConfiguration):
-      return [False, "dh_ag must be of type DHAGGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint3_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_dh_pgc(self, value: DHPGCGripperConfiguration) -> Tuple[bool, str]:
+  def validate_joint3_rpy(self, value: FloatList) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "joint3_rpy is required for URDFParameters"]
 
-    if not isinstance(value, DHPGCGripperConfiguration):
-      return [False, "dh_pgc must be of type DHPGCGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint3_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_dh_cgi(self, value: DHCGIGripperConfiguration) -> Tuple[bool, str]:
+  def validate_joint4_xyz(self, value: FloatList) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "joint4_xyz is required for URDFParameters"]
 
-    if not isinstance(value, DHCGIGripperConfiguration):
-      return [False, "dh_cgi must be of type DHCGIGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint4_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint4_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint4_rpy is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint4_rpy must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint5_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint5_xyz is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint5_xyz must be of type FloatList for URDFParameters, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint5_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint5_rpy is required for URDFParameters"]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "joint5_rpy must be of type FloatList for URDFParameters, 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)
+    is_valid, error_str = self.validate_joint0_xyz(self.joint0_xyz)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_ag(self.dh_ag)
+    is_valid, error_str = self.validate_joint0_rpy(self.joint0_rpy)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_pgc(self.dh_pgc)
+    is_valid, error_str = self.validate_joint1_xyz(self.joint1_xyz)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_cgi(self.dh_cgi)
+    is_valid, error_str = self.validate_joint1_rpy(self.joint1_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint2_xyz(self.joint2_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint2_rpy(self.joint2_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint3_xyz(self.joint3_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint3_rpy(self.joint3_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint4_xyz(self.joint4_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint4_rpy(self.joint4_rpy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint5_xyz(self.joint5_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint5_rpy(self.joint5_rpy)
     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 and data.get("kind") is not None else None,
-    dh_ag=parse_dhag_gripper_configuration(data["dh_ag"]) if "dh_ag" in data and data.get("dh_ag") is not None else None,
-    dh_pgc=parse_dhpgc_gripper_configuration(data["dh_pgc"]) if "dh_pgc" in data and data.get("dh_pgc") is not None else None,
-    dh_cgi=parse_dhcgi_gripper_configuration(data["dh_cgi"]) if "dh_cgi" in data and data.get("dh_cgi") is not None else None,
+def parse_urdf_parameters(data: object):
+  return URDFParameters(
+    joint0_xyz=parse_float_list(data["joint0_xyz"]) if "joint0_xyz" in data and data.get("joint0_xyz") is not None else None,
+    joint0_rpy=parse_float_list(data["joint0_rpy"]) if "joint0_rpy" in data and data.get("joint0_rpy") is not None else None,
+    joint1_xyz=parse_float_list(data["joint1_xyz"]) if "joint1_xyz" in data and data.get("joint1_xyz") is not None else None,
+    joint1_rpy=parse_float_list(data["joint1_rpy"]) if "joint1_rpy" in data and data.get("joint1_rpy") is not None else None,
+    joint2_xyz=parse_float_list(data["joint2_xyz"]) if "joint2_xyz" in data and data.get("joint2_xyz") is not None else None,
+    joint2_rpy=parse_float_list(data["joint2_rpy"]) if "joint2_rpy" in data and data.get("joint2_rpy") is not None else None,
+    joint3_xyz=parse_float_list(data["joint3_xyz"]) if "joint3_xyz" in data and data.get("joint3_xyz") is not None else None,
+    joint3_rpy=parse_float_list(data["joint3_rpy"]) if "joint3_rpy" in data and data.get("joint3_rpy") is not None else None,
+    joint4_xyz=parse_float_list(data["joint4_xyz"]) if "joint4_xyz" in data and data.get("joint4_xyz") is not None else None,
+    joint4_rpy=parse_float_list(data["joint4_rpy"]) if "joint4_rpy" in data and data.get("joint4_rpy") is not None else None,
+    joint5_xyz=parse_float_list(data["joint5_xyz"]) if "joint5_xyz" in data and data.get("joint5_xyz") is not None else None,
+    joint5_rpy=parse_float_list(data["joint5_rpy"]) if "joint5_rpy" in data and data.get("joint5_rpy") is not None else None,
   )
 
-def serialize_gripper_configuration(data: GripperConfiguration) -> object:
+def serialize_urdf_parameters(data: URDFParameters) -> 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),
+    "joint0_xyz": serialize_float_list(data.joint0_xyz),
+    "joint0_rpy": serialize_float_list(data.joint0_rpy),
+    "joint1_xyz": serialize_float_list(data.joint1_xyz),
+    "joint1_rpy": serialize_float_list(data.joint1_rpy),
+    "joint2_xyz": serialize_float_list(data.joint2_xyz),
+    "joint2_rpy": serialize_float_list(data.joint2_rpy),
+    "joint3_xyz": serialize_float_list(data.joint3_xyz),
+    "joint3_rpy": serialize_float_list(data.joint3_rpy),
+    "joint4_xyz": serialize_float_list(data.joint4_xyz),
+    "joint4_rpy": serialize_float_list(data.joint4_rpy),
+    "joint5_xyz": serialize_float_list(data.joint5_xyz),
+    "joint5_rpy": serialize_float_list(data.joint5_rpy),
+  }
+
+@dataclass
+class ForceUnit:
+  """Reusable Abstraction for force units (eg force, torque)
+"""
+  unit_kind: Union[ForceUnitKind, None] = None
+  value: Union[float, None] = None
+
+  def validate_unit_kind(self, value: ForceUnitKind) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "unit_kind is required for ForceUnit"]
+
+    if not ((isinstance(value, str) and ForceUnitKind in ['newtons', 'pounds']) or isinstance(value, ForceUnitKind)):
+      return [False, "unit_kind must be of type ForceUnitKind for ForceUnit, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_value(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "value must be of type float for ForceUnit, 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_unit_kind(self.unit_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_value(self.value)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_force_unit(data: object):
+  return ForceUnit(
+    unit_kind=parse_force_unit_kind(data["unit_kind"]) if "unit_kind" in data and data.get("unit_kind") is not None else None,
+    value=parse_f_64(data["value"]) if "value" in data and data.get("value") is not None else None,
+  )
+
+def serialize_force_unit(data: ForceUnit) -> object:
+  return {
+    "unit_kind": serialize_force_unit_kind(data.unit_kind),
+    "value": None if data.value is None else serialize_f_64(data.value),
   }
 
 @dataclass
@@ -3179,22 +3536,97 @@ def serialize_arm_joint_rotations(data: ArmJointRotations) -> object:
   }
 
 @dataclass
-class LinearUnit:
-  """Reusable Abstraction for linear units (eg distance, position, offset)
-"""
-  unit_kind: Union[LinearUnitKind, None] = None
-  value: Union[float, None] = None
+class JointState:
+  """State of a joint"""
+  braked: Union[bool, None] = None
+  connectionStatus: Union[ConnectionStatus, None] = None
+  inCollision: Union[bool, None] = None
+  disturbance: Union[JointStateDisturbance, None] = None
 
-  def validate_unit_kind(self, value: LinearUnitKind) -> Tuple[bool, str]:
+  def validate_braked(self, value: bool) -> Tuple[bool, str]:
     if value is None:
-      return [False, "unit_kind is required for LinearUnit"]
+      return [True, ""]
 
-    if not ((isinstance(value, str) and LinearUnitKind in ['millimeters', 'centimeters', 'meters', 'inches', 'feet']) or isinstance(value, LinearUnitKind)):
-      return [False, "unit_kind must be of type LinearUnitKind for LinearUnit, got " + type(value).__name__]
+    if not isinstance(value, bool):
+      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_value(self, value: float) -> Tuple[bool, str]:
+  def validate_connectionStatus(self, value: ConnectionStatus) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and ConnectionStatus in ['connected', 'disconnected', 'ready']) or isinstance(value, ConnectionStatus)):
+      return [False, "connectionStatus must be of type ConnectionStatus for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_inCollision(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "inCollision must be of type bool for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_disturbance(self, value: JointStateDisturbance) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, JointStateDisturbance):
+      return [False, "disturbance must be of type JointStateDisturbance for JointState, 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_braked(self.braked)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_connectionStatus(self.connectionStatus)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_inCollision(self.inCollision)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_disturbance(self.disturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_joint_state(data: object):
+  return JointState(
+    braked=parse_bool(data["braked"]) if "braked" in data and data.get("braked") is not None else None,
+    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data and data.get("connectionStatus") is not None else None,
+    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data and data.get("inCollision") is not None else None,
+    disturbance=parse_joint_state_disturbance(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None else None,
+  )
+
+def serialize_joint_state(data: JointState) -> object:
+  return {
+    "braked": None if data.braked is None else serialize_bool(data.braked),
+    "connectionStatus": None if data.connectionStatus is None else serialize_connection_status(data.connectionStatus),
+    "inCollision": None if data.inCollision is None else serialize_bool(data.inCollision),
+    "disturbance": None if data.disturbance is None else serialize_joint_state_disturbance(data.disturbance),
+  }
+
+@dataclass
+class LinearUnit:
+  """Reusable Abstraction for linear units (eg distance, position, offset)
+"""
+  unit_kind: Union[LinearUnitKind, None] = None
+  value: Union[float, None] = None
+
+  def validate_unit_kind(self, value: LinearUnitKind) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "unit_kind is required for LinearUnit"]
+
+    if not ((isinstance(value, str) and LinearUnitKind in ['millimeters', 'centimeters', 'meters', 'inches', 'feet']) or isinstance(value, LinearUnitKind)):
+      return [False, "unit_kind must be of type LinearUnitKind for LinearUnit, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_value(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
@@ -3246,162 +3678,957 @@ class Position:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "x must be of type float for Position, got " + type(value).__name__]
+      return [False, "x must be of type float for Position, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_y(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "y must be of type float for Position, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_z(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "z must be of type float for Position, 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_unit_kind(self.unit_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_x(self.x)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_y(self.y)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_z(self.z)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_position(data: object):
+  return Position(
+    unit_kind=parse_linear_unit_kind(data["unit_kind"]) if "unit_kind" in data and data.get("unit_kind") is not None else None,
+    x=parse_f_64(data["x"]) if "x" in data and data.get("x") is not None else None,
+    y=parse_f_64(data["y"]) if "y" in data and data.get("y") is not None else None,
+    z=parse_f_64(data["z"]) if "z" in data and data.get("z") is not None else None,
+  )
+
+def serialize_position(data: Position) -> object:
+  return {
+    "unit_kind": None if data.unit_kind is None else serialize_linear_unit_kind(data.unit_kind),
+    "x": None if data.x is None else serialize_f_64(data.x),
+    "y": None if data.y is None else serialize_f_64(data.y),
+    "z": None if data.z is None else serialize_f_64(data.z),
+  }
+
+@dataclass
+class SpeedProfile:
+  """Speed profile/limits for arm movements"""
+  max_joint_speeds: Union[MaxJointSpeeds, None] = None
+  max_joint_accelerations: Union[MaxJointAcclerations, None] = None
+  max_tooltip_speed: Union[float, None] = None
+  base_acceleration_scaling: Union[float, None] = None
+  base_velocity_scaling: Union[float, None] = None
+  scaling_factor: Union[float, None] = None
+
+  def validate_max_joint_speeds(self, value: MaxJointSpeeds) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, tuple) and len(value) == 6):
+      return [False, "max_joint_speeds must be of type MaxJointSpeeds for SpeedProfile, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_joint_accelerations(self, value: MaxJointAcclerations) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, tuple) and len(value) == 6):
+      return [False, "max_joint_accelerations must be of type MaxJointAcclerations for SpeedProfile, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_tooltip_speed(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "max_tooltip_speed must be of type float for SpeedProfile, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_base_acceleration_scaling(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "base_acceleration_scaling must be of type float for SpeedProfile, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_base_velocity_scaling(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "base_velocity_scaling must be of type float for SpeedProfile, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_scaling_factor(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "scaling_factor must be of type float for SpeedProfile, 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_max_joint_speeds(self.max_joint_speeds)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_joint_accelerations(self.max_joint_accelerations)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_tooltip_speed(self.max_tooltip_speed)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_base_acceleration_scaling(self.base_acceleration_scaling)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_base_velocity_scaling(self.base_velocity_scaling)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_scaling_factor(self.scaling_factor)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_speed_profile(data: object):
+  return SpeedProfile(
+    max_joint_speeds=parse_max_joint_speeds(data["max_joint_speeds"]) if "max_joint_speeds" in data and data.get("max_joint_speeds") is not None else None,
+    max_joint_accelerations=parse_max_joint_acclerations(data["max_joint_accelerations"]) if "max_joint_accelerations" in data and data.get("max_joint_accelerations") is not None else None,
+    max_tooltip_speed=parse_f_64(data["max_tooltip_speed"]) if "max_tooltip_speed" in data and data.get("max_tooltip_speed") is not None else None,
+    base_acceleration_scaling=parse_f_64(data["base_acceleration_scaling"]) if "base_acceleration_scaling" in data and data.get("base_acceleration_scaling") is not None else None,
+    base_velocity_scaling=parse_f_64(data["base_velocity_scaling"]) if "base_velocity_scaling" in data and data.get("base_velocity_scaling") is not None else None,
+    scaling_factor=parse_f_64(data["scaling_factor"]) if "scaling_factor" in data and data.get("scaling_factor") is not None else None,
+  )
+
+def serialize_speed_profile(data: SpeedProfile) -> object:
+  return {
+    "max_joint_speeds": None if data.max_joint_speeds is None else serialize_max_joint_speeds(data.max_joint_speeds),
+    "max_joint_accelerations": None if data.max_joint_accelerations is None else serialize_max_joint_acclerations(data.max_joint_accelerations),
+    "max_tooltip_speed": None if data.max_tooltip_speed is None else serialize_f_64(data.max_tooltip_speed),
+    "base_acceleration_scaling": None if data.base_acceleration_scaling is None else serialize_f_64(data.base_acceleration_scaling),
+    "base_velocity_scaling": None if data.base_velocity_scaling is None else serialize_f_64(data.base_velocity_scaling),
+    "scaling_factor": None if data.scaling_factor is None else serialize_f_64(data.scaling_factor),
+  }
+
+@dataclass
+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[str, 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 OnRobot2FG14GripperConfiguration, 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 OnRobot2FG14GripperConfiguration, 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 OnRobot2FG14GripperConfiguration, 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 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: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "finger_mounting_position must be of type str 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 and data.get("grip_kind") is not None else None,
+    grip_detected=parse_bool(data["grip_detected"]) if "grip_detected" in data and data.get("grip_detected") is not None else None,
+    normalized_width_inner=parse_f_64(data["normalized_width_inner"]) if "normalized_width_inner" in data and data.get("normalized_width_inner") is not None else None,
+    normalized_width_outer=parse_f_64(data["normalized_width_outer"]) if "normalized_width_outer" in data and data.get("normalized_width_outer") is not None else None,
+    width_inner=parse_f_64(data["width_inner"]) if "width_inner" in data and data.get("width_inner") is not None else None,
+    min_width_inner=parse_f_64(data["min_width_inner"]) if "min_width_inner" in data and data.get("min_width_inner") is not None else None,
+    max_width_inner=parse_f_64(data["max_width_inner"]) if "max_width_inner" in data and data.get("max_width_inner") is not None else None,
+    width_outer=parse_f_64(data["width_outer"]) if "width_outer" in data and data.get("width_outer") is not None else None,
+    min_width_outer=parse_f_64(data["min_width_outer"]) if "min_width_outer" in data and data.get("min_width_outer") is not None else None,
+    max_width_outer=parse_f_64(data["max_width_outer"]) if "max_width_outer" in data and data.get("max_width_outer") is not None else None,
+    force=parse_f_64(data["force"]) if "force" in data and data.get("force") is not None else None,
+    max_force=parse_f_64(data["max_force"]) if "max_force" in data and data.get("max_force") is not None else None,
+    finger_mounting_position=parse_str(data["finger_mounting_position"]) if "finger_mounting_position" in data and data.get("finger_mounting_position") is not None else None,
+    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data and data.get("finger_offset") is not None else None,
+    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data and data.get("finger_angle") is not None else None,
+    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data and data.get("finger_length") is not None else None,
+    finger_height=parse_f_64(data["finger_height"]) if "finger_height" in data and data.get("finger_height") is not None else None,
+    linear_sensor_error=parse_bool(data["linear_sensor_error"]) if "linear_sensor_error" in data and data.get("linear_sensor_error") is not None else None,
+    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data and data.get("uncalibrated_error") is not None 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_str(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[str, 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: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "finger_mounting_position must be of type str 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 and data.get("grip_kind") is not None else None,
+    grip_detected=parse_bool(data["grip_detected"]) if "grip_detected" in data and data.get("grip_detected") is not None else None,
+    normalized_width_inner=parse_f_64(data["normalized_width_inner"]) if "normalized_width_inner" in data and data.get("normalized_width_inner") is not None else None,
+    normalized_width_outer=parse_f_64(data["normalized_width_outer"]) if "normalized_width_outer" in data and data.get("normalized_width_outer") is not None else None,
+    width_inner=parse_f_64(data["width_inner"]) if "width_inner" in data and data.get("width_inner") is not None else None,
+    min_width_inner=parse_f_64(data["min_width_inner"]) if "min_width_inner" in data and data.get("min_width_inner") is not None else None,
+    max_width_inner=parse_f_64(data["max_width_inner"]) if "max_width_inner" in data and data.get("max_width_inner") is not None else None,
+    width_outer=parse_f_64(data["width_outer"]) if "width_outer" in data and data.get("width_outer") is not None else None,
+    min_width_outer=parse_f_64(data["min_width_outer"]) if "min_width_outer" in data and data.get("min_width_outer") is not None else None,
+    max_width_outer=parse_f_64(data["max_width_outer"]) if "max_width_outer" in data and data.get("max_width_outer") is not None else None,
+    force=parse_f_64(data["force"]) if "force" in data and data.get("force") is not None else None,
+    max_force=parse_f_64(data["max_force"]) if "max_force" in data and data.get("max_force") is not None else None,
+    finger_mounting_position=parse_str(data["finger_mounting_position"]) if "finger_mounting_position" in data and data.get("finger_mounting_position") is not None else None,
+    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data and data.get("finger_offset") is not None else None,
+    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data and data.get("finger_angle") is not None else None,
+    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data and data.get("finger_length") is not None else None,
+    finger_height=parse_f_64(data["finger_height"]) if "finger_height" in data and data.get("finger_height") is not None else None,
+    linear_sensor_error=parse_bool(data["linear_sensor_error"]) if "linear_sensor_error" in data and data.get("linear_sensor_error") is not None else None,
+    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data and data.get("uncalibrated_error") is not None 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_str(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_y(self, value: float) -> Tuple[bool, str]:
+  def validate_grip_kind(self, value: OnRobotGripKindEnum) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "y must be of type float for Position, 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 OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_z(self, value: float) -> Tuple[bool, str]:
+  def validate_finger_angle(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "z must be of type float for Position, got " + type(value).__name__]
+      return [False, "finger_angle 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_unit_kind(self.unit_kind)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_x(self.x)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_y(self.y)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_z(self.z)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_position(data: object):
-  return Position(
-    unit_kind=parse_linear_unit_kind(data["unit_kind"]) if "unit_kind" in data and data.get("unit_kind") is not None else None,
-    x=parse_f_64(data["x"]) if "x" in data and data.get("x") is not None else None,
-    y=parse_f_64(data["y"]) if "y" in data and data.get("y") is not None else None,
-    z=parse_f_64(data["z"]) if "z" in data and data.get("z") is not None else None,
-  )
-
-def serialize_position(data: Position) -> object:
-  return {
-    "unit_kind": None if data.unit_kind is None else serialize_linear_unit_kind(data.unit_kind),
-    "x": None if data.x is None else serialize_f_64(data.x),
-    "y": None if data.y is None else serialize_f_64(data.y),
-    "z": None if data.z is None else serialize_f_64(data.z),
-  }
-
-@dataclass
-class SpeedProfile:
-  """Speed profile/limits for arm movements"""
-  max_joint_speeds: Union[MaxJointSpeeds, None] = None
-  max_joint_accelerations: Union[MaxJointAcclerations, None] = None
-  max_tooltip_speed: Union[float, None] = None
-  base_acceleration_scaling: Union[float, None] = None
-  base_velocity_scaling: Union[float, None] = None
-  scaling_factor: Union[float, None] = None
-
-  def validate_max_joint_speeds(self, value: MaxJointSpeeds) -> Tuple[bool, str]:
+  def validate_force_applied_fraction(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not (isinstance(value, tuple) and len(value) == 6):
-      return [False, "max_joint_speeds must be of type MaxJointSpeeds for SpeedProfile, got " + type(value).__name__]
+    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_max_joint_accelerations(self, value: MaxJointAcclerations) -> Tuple[bool, str]:
+  def validate_force_applied_newtons(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not (isinstance(value, tuple) and len(value) == 6):
-      return [False, "max_joint_accelerations must be of type MaxJointAcclerations for SpeedProfile, got " + type(value).__name__]
+    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_max_tooltip_speed(self, value: float) -> Tuple[bool, str]:
+  def validate_target_force_newtons(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "max_tooltip_speed must be of type float for SpeedProfile, got " + type(value).__name__]
+      return [False, "target_force_newtons must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_base_acceleration_scaling(self, value: float) -> Tuple[bool, str]:
+  def validate_finger_length(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "base_acceleration_scaling must be of type float for SpeedProfile, got " + type(value).__name__]
+      return [False, "finger_length must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_base_velocity_scaling(self, value: float) -> Tuple[bool, str]:
+  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "base_velocity_scaling must be of type float for SpeedProfile, got " + type(value).__name__]
+      return [False, "finger_mounting_position must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_scaling_factor(self, value: float) -> Tuple[bool, str]:
+  def validate_finger_offset(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "scaling_factor must be of type float for SpeedProfile, got " + type(value).__name__]
+      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_max_joint_speeds(self.max_joint_speeds)
+    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_max_joint_accelerations(self.max_joint_accelerations)
+    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_max_tooltip_speed(self.max_tooltip_speed)
+    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_base_acceleration_scaling(self.base_acceleration_scaling)
+    is_valid, error_str = self.validate_diameter(self.diameter)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_base_velocity_scaling(self.base_velocity_scaling)
+    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_scaling_factor(self.scaling_factor)
+    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_speed_profile(data: object):
-  return SpeedProfile(
-    max_joint_speeds=parse_max_joint_speeds(data["max_joint_speeds"]) if "max_joint_speeds" in data and data.get("max_joint_speeds") is not None else None,
-    max_joint_accelerations=parse_max_joint_acclerations(data["max_joint_accelerations"]) if "max_joint_accelerations" in data and data.get("max_joint_accelerations") is not None else None,
-    max_tooltip_speed=parse_f_64(data["max_tooltip_speed"]) if "max_tooltip_speed" in data and data.get("max_tooltip_speed") is not None else None,
-    base_acceleration_scaling=parse_f_64(data["base_acceleration_scaling"]) if "base_acceleration_scaling" in data and data.get("base_acceleration_scaling") is not None else None,
-    base_velocity_scaling=parse_f_64(data["base_velocity_scaling"]) if "base_velocity_scaling" in data and data.get("base_velocity_scaling") is not None else None,
-    scaling_factor=parse_f_64(data["scaling_factor"]) if "scaling_factor" in data and data.get("scaling_factor") is not None else None,
+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 and data.get("grip_detected") is not None else None,
+    force_grip_detected=parse_bool(data["force_grip_detected"]) if "force_grip_detected" in data and data.get("force_grip_detected") is not None else None,
+    calibration_ok=parse_bool(data["calibration_ok"]) if "calibration_ok" in data and data.get("calibration_ok") is not None else None,
+    diameter=parse_f_64(data["diameter"]) if "diameter" in data and data.get("diameter") is not None else None,
+    grip_kind=parse_on_robot_grip_kind_enum(data["grip_kind"]) if "grip_kind" in data and data.get("grip_kind") is not None else None,
+    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data and data.get("finger_angle") is not None else None,
+    force_applied_fraction=parse_f_64(data["force_applied_fraction"]) if "force_applied_fraction" in data and data.get("force_applied_fraction") is not None else None,
+    force_applied_newtons=parse_f_64(data["force_applied_newtons"]) if "force_applied_newtons" in data and data.get("force_applied_newtons") is not None else None,
+    target_force_newtons=parse_f_64(data["target_force_newtons"]) if "target_force_newtons" in data and data.get("target_force_newtons") is not None else None,
+    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data and data.get("finger_length") is not None else None,
+    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data and data.get("finger_mounting_position") is not None else None,
+    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data and data.get("finger_offset") is not None else None,
   )
 
-def serialize_speed_profile(data: SpeedProfile) -> object:
+def serialize_on_robot_3_fg_15_gripper_configuration(data: OnRobot3FG15GripperConfiguration) -> object:
   return {
-    "max_joint_speeds": None if data.max_joint_speeds is None else serialize_max_joint_speeds(data.max_joint_speeds),
-    "max_joint_accelerations": None if data.max_joint_accelerations is None else serialize_max_joint_acclerations(data.max_joint_accelerations),
-    "max_tooltip_speed": None if data.max_tooltip_speed is None else serialize_f_64(data.max_tooltip_speed),
-    "base_acceleration_scaling": None if data.base_acceleration_scaling is None else serialize_f_64(data.base_acceleration_scaling),
-    "base_velocity_scaling": None if data.base_velocity_scaling is None else serialize_f_64(data.base_velocity_scaling),
-    "scaling_factor": None if data.scaling_factor is None else serialize_f_64(data.scaling_factor),
+    "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]
@@ -3502,36 +4729,6 @@ def serialize_orientation(data: Orientation) -> object:
     "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, ""]
-
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_state(self.state)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_recovery_status_response(data: object):
-  return RecoveryStatusResponse(
-    state=parse_recovery_state_enum(data["state"]) if "state" in data and data.get("state") is not None else None,
-  )
-
-def serialize_recovery_status_response(data: RecoveryStatusResponse) -> object:
-  return {
-    "state": None if data.state is None else serialize_recovery_state_enum(data.state),
-  }
-
 @dataclass
 class FailureStateDetails:
   """Failure state details."""
@@ -3861,75 +5058,203 @@ class StatusHealthResponse:
   health: Union[StatusHealthEnum, None] = None
   build: Union[StatusVersionData, None] = None
 
-  def validate_health(self, value: StatusHealthEnum) -> Tuple[bool, str]:
+  def validate_health(self, value: StatusHealthEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and StatusHealthEnum in ['ok', 'warning', 'error']) or isinstance(value, StatusHealthEnum)):
+      return [False, "health must be of type StatusHealthEnum for StatusHealthResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_build(self, value: StatusVersionData) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, StatusVersionData):
+      return [False, "build must be of type StatusVersionData for StatusHealthResponse, 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_health(self.health)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_build(self.build)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_status_health_response(data: object):
+  return StatusHealthResponse(
+    health=parse_status_health_enum(data["health"]) if "health" in data and data.get("health") is not None else None,
+    build=parse_status_version_data(data["build"]) if "build" in data and data.get("build") is not None else None,
+  )
+
+def serialize_status_health_response(data: StatusHealthResponse) -> object:
+  return {
+    "health": None if data.health is None else serialize_status_health_enum(data.health),
+    "build": None if data.build is None else serialize_status_version_data(data.build),
+  }
+
+@dataclass
+class ArmPositionUpdateRequestResponseEventStreamDetails:
+  """Specify how the response should be sent
+"""
+  subscriptions: Union[ArmPositionUpdateRequestResponseEventStreamSubscriptionsList, None] = None
+
+  def validate_subscriptions(self, value: ArmPositionUpdateRequestResponseEventStreamSubscriptionsList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "subscriptions is required for ArmPositionUpdateRequestResponseEventStreamDetails"]
+
+    if not (isinstance(value, list) and all(((isinstance(x, str) and ArmPositionUpdateRequestResponseEventStreamSubscriptionKindEnum in ['all', 'events', 'positions']) or isinstance(x, ArmPositionUpdateRequestResponseEventStreamSubscriptionKindEnum)) for x in value)):
+      return [False, "subscriptions must be of type ArmPositionUpdateRequestResponseEventStreamSubscriptionsList for ArmPositionUpdateRequestResponseEventStreamDetails, 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_subscriptions(self.subscriptions)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_arm_position_update_request_response_event_stream_details(data: object):
+  return ArmPositionUpdateRequestResponseEventStreamDetails(
+    subscriptions=parse_arm_position_update_request_response_event_stream_subscriptions_list(data["subscriptions"]) if "subscriptions" in data and data.get("subscriptions") is not None else None,
+  )
+
+def serialize_arm_position_update_request_response_event_stream_details(data: ArmPositionUpdateRequestResponseEventStreamDetails) -> object:
+  return {
+    "subscriptions": serialize_arm_position_update_request_response_event_stream_subscriptions_list(data.subscriptions),
+  }
+
+@dataclass
+class Routine:
+  """Robot Routine containing steps to automate robot movement and operations"""
+  id: Union[str, None] = None
+  name: Union[str, None] = None
+  environment_variables: Union[EnvironmentVariablesList, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for Routine, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_name(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "name must be of type str for Routine, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_environment_variables(self, value: EnvironmentVariablesList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, EnvironmentVariable) for x in value)):
+      return [False, "environment_variables must be of type EnvironmentVariablesList for Routine, 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_id(self.id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_name(self.name)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_environment_variables(self.environment_variables)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_routine(data: object):
+  return Routine(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
+    environment_variables=parse_environment_variables_list(data["environment_variables"]) if "environment_variables" in data and data.get("environment_variables") is not None else None,
+  )
+
+def serialize_routine(data: Routine) -> object:
+  return {
+    "id": None if data.id is None else serialize_str(data.id),
+    "name": None if data.name is None else serialize_str(data.name),
+    "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
+  }
+
+@dataclass
+class CalibrationData:
+  """The result of a calibration"""
+  timestamp: Union[str, None] = None
+  armSerial: Union[str, None] = None
+  urdfParameters: Union[URDFParameters, None] = None
+
+  def validate_timestamp(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "timestamp is required for CalibrationData"]
+
+    if not isinstance(value, str):
+      return [False, "timestamp must be of type str for CalibrationData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_armSerial(self, value: str) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "armSerial is required for CalibrationData"]
 
-    if not ((isinstance(value, str) and StatusHealthEnum in ['ok', 'warning', 'error']) or isinstance(value, StatusHealthEnum)):
-      return [False, "health must be of type StatusHealthEnum for StatusHealthResponse, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "armSerial must be of type str for CalibrationData, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_build(self, value: StatusVersionData) -> Tuple[bool, str]:
+  def validate_urdfParameters(self, value: URDFParameters) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "urdfParameters is required for CalibrationData"]
 
-    if not isinstance(value, StatusVersionData):
-      return [False, "build must be of type StatusVersionData for StatusHealthResponse, got " + type(value).__name__]
+    if not isinstance(value, URDFParameters):
+      return [False, "urdfParameters must be of type URDFParameters for CalibrationData, 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_health(self.health)
+    is_valid, error_str = self.validate_timestamp(self.timestamp)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_build(self.build)
+    is_valid, error_str = self.validate_armSerial(self.armSerial)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_urdfParameters(self.urdfParameters)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_status_health_response(data: object):
-  return StatusHealthResponse(
-    health=parse_status_health_enum(data["health"]) if "health" in data and data.get("health") is not None else None,
-    build=parse_status_version_data(data["build"]) if "build" in data and data.get("build") is not None else None,
+def parse_calibration_data(data: object):
+  return CalibrationData(
+    timestamp=parse_str(data["timestamp"]) if "timestamp" in data and data.get("timestamp") is not None else None,
+    armSerial=parse_str(data["armSerial"]) if "armSerial" in data and data.get("armSerial") is not None else None,
+    urdfParameters=parse_urdf_parameters(data["urdfParameters"]) if "urdfParameters" in data and data.get("urdfParameters") is not None else None,
   )
 
-def serialize_status_health_response(data: StatusHealthResponse) -> object:
+def serialize_calibration_data(data: CalibrationData) -> object:
   return {
-    "health": None if data.health is None else serialize_status_health_enum(data.health),
-    "build": None if data.build is None else serialize_status_version_data(data.build),
+    "timestamp": serialize_str(data.timestamp),
+    "armSerial": serialize_str(data.armSerial),
+    "urdfParameters": serialize_urdf_parameters(data.urdfParameters),
   }
 
-@dataclass
-class ArmPositionUpdateRequestResponseEventStreamDetails:
-  """Specify how the response should be sent
-"""
-  subscriptions: Union[ArmPositionUpdateRequestResponseEventStreamSubscriptionsList, None] = None
-
-  def validate_subscriptions(self, value: ArmPositionUpdateRequestResponseEventStreamSubscriptionsList) -> Tuple[bool, str]:
-    if value is None:
-      return [False, "subscriptions is required for ArmPositionUpdateRequestResponseEventStreamDetails"]
-
-    if not (isinstance(value, list) and all(((isinstance(x, str) and ArmPositionUpdateRequestResponseEventStreamSubscriptionKindEnum in ['all', 'events', 'positions']) or isinstance(x, ArmPositionUpdateRequestResponseEventStreamSubscriptionKindEnum)) for x in value)):
-      return [False, "subscriptions must be of type ArmPositionUpdateRequestResponseEventStreamSubscriptionsList for ArmPositionUpdateRequestResponseEventStreamDetails, 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_subscriptions(self.subscriptions)
-    if not is_valid:
-      raise TypeError(error_str)
+ArmJointRotationsList = List[ArmJointRotations]
 
-def parse_arm_position_update_request_response_event_stream_details(data: object):
-  return ArmPositionUpdateRequestResponseEventStreamDetails(
-    subscriptions=parse_arm_position_update_request_response_event_stream_subscriptions_list(data["subscriptions"]) if "subscriptions" in data and data.get("subscriptions") is not None else None,
-  )
+def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
+  return [parse_arm_joint_rotations(item) for item in data]
 
-def serialize_arm_position_update_request_response_event_stream_details(data: ArmPositionUpdateRequestResponseEventStreamDetails) -> object:
-  return {
-    "subscriptions": serialize_arm_position_update_request_response_event_stream_subscriptions_list(data.subscriptions),
-  }
+def serialize_arm_joint_rotations_list(data: ArmJointRotationsList) -> List[object]:
+  return [serialize_arm_joint_rotations(item) for item in data]
 
 @dataclass
 class JointsStateResponse:
@@ -4036,74 +5361,6 @@ def serialize_joints_state_response(data: JointsStateResponse) -> object:
     "J5": None if data.J5 is None else serialize_joint_state(data.J5),
   }
 
-@dataclass
-class Routine:
-  """Robot Routine containing steps to automate robot movement and operations"""
-  id: Union[str, None] = None
-  name: Union[str, None] = None
-  environment_variables: Union[EnvironmentVariablesList, None] = None
-
-  def validate_id(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, str):
-      return [False, "id must be of type str for Routine, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_name(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, str):
-      return [False, "name must be of type str for Routine, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_environment_variables(self, value: EnvironmentVariablesList) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not (isinstance(value, list) and all(isinstance(x, EnvironmentVariable) for x in value)):
-      return [False, "environment_variables must be of type EnvironmentVariablesList for Routine, 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_id(self.id)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_name(self.name)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_environment_variables(self.environment_variables)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_routine(data: object):
-  return Routine(
-    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
-    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
-    environment_variables=parse_environment_variables_list(data["environment_variables"]) if "environment_variables" in data and data.get("environment_variables") is not None else None,
-  )
-
-def serialize_routine(data: Routine) -> object:
-  return {
-    "id": None if data.id is None else serialize_str(data.id),
-    "name": None if data.name is None else serialize_str(data.name),
-    "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
-  }
-
-ArmJointRotationsList = List[ArmJointRotations]
-
-def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
-  return [parse_arm_joint_rotations(item) for item in data]
-
-def serialize_arm_joint_rotations_list(data: ArmJointRotationsList) -> List[object]:
-  return [serialize_arm_joint_rotations(item) for item in data]
-
 @dataclass
 class OnRobot2FG14GripperCommandRequest:
   """Control the OnRobot 2FG14 gripper (end effector) of the robot
@@ -4378,6 +5635,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 and data.get("kind") is not None else None,
+    onrobot_2fg7=parse_on_robot_2_fg_7_gripper_configuration(data["onrobot_2fg7"]) if "onrobot_2fg7" in data and data.get("onrobot_2fg7") is not None else None,
+    onrobot_2fg14=parse_on_robot_2_fg_14_gripper_configuration(data["onrobot_2fg14"]) if "onrobot_2fg14" in data and data.get("onrobot_2fg14") is not None else None,
+    onrobot_3fg15=parse_on_robot_3_fg_15_gripper_configuration(data["onrobot_3fg15"]) if "onrobot_3fg15" in data and data.get("onrobot_3fg15") is not None else None,
+    onrobot_screwdriver=parse_on_robot_screwdriver_configuration(data["onrobot_screwdriver"]) if "onrobot_screwdriver" in data and data.get("onrobot_screwdriver") is not None else None,
+    dh_ag=parse_dhag_gripper_configuration(data["dh_ag"]) if "dh_ag" in data and data.get("dh_ag") is not None else None,
+    dh_pgc=parse_dhpgc_gripper_configuration(data["dh_pgc"]) if "dh_pgc" in data and data.get("dh_pgc") is not None else None,
+    dh_cgi=parse_dhcgi_gripper_configuration(data["dh_cgi"]) if "dh_cgi" in data and data.get("dh_cgi") is not None 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"""
@@ -4524,9 +5916,19 @@ def serialize_position_and_orientation(data: PositionAndOrientation) -> object:
 @dataclass
 class FailureStateResponse:
   """Failure state response informs user of how and whether the robot may be recovered."""
+  status: Union[RobotStatusEnum, None] = None
   failed: Union[bool, None] = None
   failure: Union[FailureStateDetails, None] = None
 
+  def validate_status(self, value: RobotStatusEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RobotStatusEnum in ['Idle', 'RunningAdHocCommand', 'RoutineRunning', 'Antigravity', 'AntigravitySlow', 'Failure', 'Recovering']) or isinstance(value, RobotStatusEnum)):
+      return [False, "status must be of type RobotStatusEnum for FailureStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
   def validate_failed(self, value: bool) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
@@ -4547,6 +5949,9 @@ class FailureStateResponse:
 
   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_failed(self.failed)
     if not is_valid:
       raise TypeError(error_str)
@@ -4556,12 +5961,14 @@ class FailureStateResponse:
 
 def parse_failure_state_response(data: object):
   return FailureStateResponse(
+    status=parse_robot_status_enum(data["status"]) if "status" in data and data.get("status") is not None else None,
     failed=parse_bool(data["failed"]) if "failed" in data and data.get("failed") is not None else None,
     failure=parse_failure_state_details(data["failure"]) if "failure" in data and data.get("failure") is not None else None,
   )
 
 def serialize_failure_state_response(data: FailureStateResponse) -> object:
   return {
+    "status": None if data.status is None else serialize_robot_status_enum(data.status),
     "failed": None if data.failed is None else serialize_bool(data.failed),
     "failure": None if data.failure is None else serialize_failure_state_details(data.failure),
   }
@@ -4650,6 +6057,36 @@ def parse_routines_list(data: object) -> RoutinesList:
 def serialize_routines_list(data: RoutinesList) -> List[object]:
   return [serialize_routine(item) for item in data]
 
+@dataclass
+class ActiveCalibrationResponse:
+  """The response to an active calibration request"""
+  calibrationData: Union[CalibrationData, None] = None
+
+  def validate_calibrationData(self, value: CalibrationData) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, CalibrationData):
+      return [False, "calibrationData must be of type CalibrationData for ActiveCalibrationResponse, 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_calibrationData(self.calibrationData)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_active_calibration_response(data: object):
+  return ActiveCalibrationResponse(
+    calibrationData=parse_calibration_data(data["calibrationData"]) if "calibrationData" in data and data.get("calibrationData") is not None else None,
+  )
+
+def serialize_active_calibration_response(data: ActiveCalibrationResponse) -> object:
+  return {
+    "calibrationData": None if data.calibrationData is None else serialize_calibration_data(data.calibrationData),
+  }
+
 @dataclass
 class GripperCommandRequest:
   """Control the gripper (end effector) of the robot
@@ -4667,7 +6104,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, ""]
@@ -4793,7 +6230,7 @@ class Space:
   kind: Union[str, None] = None
   name: Union[str, None] = None
   description: Union[str, None] = None
-  isGlobal: Union[bool, None] = None
+  is_global: Union[bool, None] = None
   positions: Union[SpacePositionsMap, None] = None
 
   def validate_id(self, value: str) -> Tuple[bool, str]:
@@ -4832,12 +6269,12 @@ class Space:
 
     return [True, ""]
 
-  def validate_isGlobal(self, value: bool) -> Tuple[bool, str]:
+  def validate_is_global(self, value: bool) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, bool):
-      return [False, "isGlobal must be of type bool for Space, got " + type(value).__name__]
+      return [False, "is_global must be of type bool for Space, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -4864,7 +6301,7 @@ class Space:
     is_valid, error_str = self.validate_description(self.description)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_isGlobal(self.isGlobal)
+    is_valid, error_str = self.validate_is_global(self.is_global)
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_positions(self.positions)
@@ -4877,7 +6314,7 @@ def parse_space(data: object):
     kind=parse_str(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
     name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
     description=parse_str(data["description"]) if "description" in data and data.get("description") is not None else None,
-    isGlobal=parse_bool(data["isGlobal"]) if "isGlobal" in data and data.get("isGlobal") is not None else None,
+    is_global=parse_bool(data["is_global"]) if "is_global" in data and data.get("is_global") is not None else None,
     positions=parse_space_positions_map(data["positions"]) if "positions" in data and data.get("positions") is not None else None,
   )
 
@@ -4887,7 +6324,7 @@ def serialize_space(data: Space) -> object:
     "kind": None if data.kind is None else serialize_str(data.kind),
     "name": None if data.name is None else serialize_str(data.name),
     "description": None if data.description is None else serialize_str(data.description),
-    "isGlobal": None if data.isGlobal is None else serialize_bool(data.isGlobal),
+    "is_global": None if data.is_global is None else serialize_bool(data.is_global),
     "positions": None if data.positions is None else serialize_space_positions_map(data.positions),
   }