standardbots 2.0.0.dev1737138088__py3-none-any.whl → 2.0.0.dev1740502639__py3-none-any.whl

standardbots/auto_generated/models.py

@@ -551,6 +551,51 @@ def serialize_camera_settings(data: CameraSettings) -> object:
     "autoWhiteBalance": None if data.autoWhiteBalance is None else serialize_bool(data.autoWhiteBalance),
   }
 
+@dataclass
+class CameraStatus:
+  """Current camera status."""
+  connected: Union[bool, None] = None
+  message: Union[str, None] = None
+
+  def validate_connected(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "connected must be of type bool for CameraStatus, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_message(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "message must be of type str for CameraStatus, 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_connected(self.connected)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_message(self.message)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_status(data: object):
+  return CameraStatus(
+    connected=parse_bool(data["connected"]) if "connected" in data and data.get("connected") is not None else None,
+    message=parse_str(data["message"]) if "message" in data and data.get("message") is not None else None,
+  )
+
+def serialize_camera_status(data: CameraStatus) -> object:
+  return {
+    "connected": None if data.connected is None else serialize_bool(data.connected),
+    "message": None if data.message is None else serialize_str(data.message),
+  }
+
 @dataclass
 class CartesianPose:
   """Cartesian pose
@@ -1087,6 +1132,18 @@ class ErrorEnum(Enum):
   """Requested resource not found"""
   InvalidSpaceSpecified = "invalid_space_specified"
   """Space specified was invalid or not found"""
+  InvalidParameters = "invalid_parameters"
+  """Parameters are invalid"""
+  RoutineDoesNotExist = "routine_does_not_exist"
+  """Routine does not exist"""
+  CannotPlayRoutine = "cannot_play_routine"
+  """Routine is not in the correct state to play"""
+  RoutineMustBePlaying = "routine_must_be_playing"
+  """Routine must be playing"""
+  CannotChangeRosState = "cannot_change_ros_state"
+  """Cannot change ROS state"""
+  IoSafeguardError = "io_safeguard_error"
+  """Cannot change IO state because of safeguard"""
 
 def parse_error_enum(data: object) -> ErrorEnum:
   return ErrorEnum(data)
@@ -1200,6 +1257,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`"""
@@ -1372,11 +1437,71 @@ 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"""
-  Outward = "outward"
-  """Grip gripper outward to grip. Measure grip position based on exterior of gripper fingers and interior of object"""
+  Internal = "internal"
+  """Grip object on the inside of gripper fingers. Measure grip position based on interior of gripper fingers and exterior of object"""
+  External = "external"
+  """Grip object on the outside of gripper fingers. Measure grip position based on exterior of gripper fingers and interior of object"""
 
 def parse_linear_grip_direction_enum(data: object) -> LinearGripDirectionEnum:
   return LinearGripDirectionEnum(data)
@@ -1469,10 +1594,10 @@ def serialize_on_robot_3_fg_15_control_kind_enum(data: Union[OnRobot3FG15Control
   return OnRobot3FG15ControlKindEnum(data).value
 
 class OnRobotGripKindEnum(Enum):
-  Inward = "inward"
-  """Enum Inward = `inward`"""
-  Outward = "outward"
-  """Enum Outward = `outward`"""
+  Internal = "internal"
+  """Enum Internal = `internal`"""
+  External = "external"
+  """Enum External = `external`"""
 
 def parse_on_robot_grip_kind_enum(data: object) -> OnRobotGripKindEnum:
   return OnRobotGripKindEnum(data)
@@ -2623,39 +2748,9 @@ def serialize_brakes_state(data: BrakesState) -> object:
     "state": serialize_brakes_state_enum(data.state),
   }
 
-@dataclass
-class CameraIntrinsicsResponse:
-  """Response with intrinsic parameters of the camera."""
-  intrinsics: Union[CameraIntrinsics, None] = None
-
-  def validate_intrinsics(self, value: CameraIntrinsics) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, CameraIntrinsics):
-      return [False, "intrinsics must be of type CameraIntrinsics for CameraIntrinsicsResponse, 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_intrinsics(self.intrinsics)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_camera_intrinsics_response(data: object):
-  return CameraIntrinsicsResponse(
-    intrinsics=parse_camera_intrinsics(data["intrinsics"]) if "intrinsics" in data and data.get("intrinsics") is not None else None,
-  )
-
-def serialize_camera_intrinsics_response(data: CameraIntrinsicsResponse) -> object:
-  return {
-    "intrinsics": None if data.intrinsics is None else serialize_camera_intrinsics(data.intrinsics),
-  }
-
 @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]:
@@ -2959,81 +3054,6 @@ 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
-
-  def validate_braked(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, bool):
-      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
-
-    return [True, ""]
-
-  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: 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:
@@ -3052,7 +3072,7 @@ class ErrorResponse:
     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)):
+    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', 'routine_does_not_exist', 'cannot_play_routine', 'routine_must_be_playing', 'cannot_change_ros_state', 'io_safeguard_error']) or isinstance(value, ErrorEnum)):
       return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
@@ -3149,92 +3169,287 @@ 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 IOStateResponse:
-  """Response to a query for the current state of I/O."""
-  state: Union[IOStateMap, 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_state(self, value: IOStateMap) -> 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 [True, ""]
+      return [False, "joint2_rpy is required for URDFParameters"]
 
-    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
-      return [False, "state must be of type IOStateMap for IOStateResponse, 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 __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 validate_joint3_xyz(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint3_xyz is required for URDFParameters"]
 
-def parse_io_state_response(data: object):
-  return IOStateResponse(
-    state=parse_io_state_map(data["state"]) if "state" in data and data.get("state") is not None else None,
-  )
+    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__]
 
-def serialize_io_state_response(data: IOStateResponse) -> object:
-  return {
-    "state": None if data.state is None else serialize_io_state_map(data.state),
-  }
+    return [True, ""]
 
-@dataclass
-class IOStateUpdateRequest:
-  """Request to update the state of I/O for multiple ports."""
-  state: Union[IOStateMap, None] = None
+  def validate_joint3_rpy(self, value: FloatList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "joint3_rpy is required for URDFParameters"]
 
-  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
+    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_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, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
-      return [False, "state must be of type IOStateMap for IOStateUpdateRequest, 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_joint0_xyz(self.joint0_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    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_joint1_xyz(self.joint1_xyz)
+    if not is_valid:
+      raise TypeError(error_str)
+    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_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_urdf_parameters(data: URDFParameters) -> object:
+  return {
+    "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
+class IOStateResponse:
+  """Response to a query for the current state of I/O."""
+  state: Union[IOStateMap, None] = None
+
+  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "state must be of type IOStateMap for IOStateResponse, 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_io_state_response(data: object):
+  return IOStateResponse(
+    state=parse_io_state_map(data["state"]) if "state" in data and data.get("state") is not None else None,
+  )
+
+def serialize_io_state_response(data: IOStateResponse) -> object:
+  return {
+    "state": None if data.state is None else serialize_io_state_map(data.state),
+  }
+
+@dataclass
+class IOStateUpdateRequest:
+  """Request to update the state of I/O for multiple ports."""
+  state: Union[IOStateMap, None] = None
+
+  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "state must be of type IOStateMap for IOStateUpdateRequest, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -3345,6 +3560,81 @@ def serialize_arm_joint_rotations(data: ArmJointRotations) -> object:
     "joints": serialize_joint_rotations(data.joints),
   }
 
+@dataclass
+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_braked(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  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)
@@ -3598,7 +3888,7 @@ class OnRobot2FG14GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -3898,7 +4188,7 @@ class OnRobot2FG7GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -4227,7 +4517,7 @@ class OnRobot3FG15GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -4599,6 +4889,36 @@ def serialize_robot_control_mode(data: RobotControlMode) -> object:
     "kind": None if data.kind is None else serialize_robot_control_mode_enum(data.kind),
   }
 
+@dataclass
+class PlayRoutineResponse:
+  """Status response informs user of of robot state"""
+  status: Union[RobotStatusEnum, 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 PlayRoutineResponse, 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)
+
+def parse_play_routine_response(data: object):
+  return PlayRoutineResponse(
+    status=parse_robot_status_enum(data["status"]) if "status" in data and data.get("status") is not None else None,
+  )
+
+def serialize_play_routine_response(data: PlayRoutineResponse) -> object:
+  return {
+    "status": None if data.status is None else serialize_robot_status_enum(data.status),
+  }
+
 @dataclass
 class ROSControlStateResponse:
   """Response to a query for the current state of ROS control."""
@@ -4863,6 +5183,134 @@ def serialize_arm_position_update_request_response_event_stream_details(data: Ar
     "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 [False, "armSerial is required for CalibrationData"]
+
+    if not isinstance(value, str):
+      return [False, "armSerial must be of type str for CalibrationData, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_urdfParameters(self, value: URDFParameters) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "urdfParameters is required for CalibrationData"]
+
+    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_timestamp(self.timestamp)
+    if not is_valid:
+      raise TypeError(error_str)
+    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_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_calibration_data(data: CalibrationData) -> object:
+  return {
+    "timestamp": serialize_str(data.timestamp),
+    "armSerial": serialize_str(data.armSerial),
+    "urdfParameters": serialize_urdf_parameters(data.urdfParameters),
+  }
+
+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 JointsStateResponse:
   """Response to a query for the current state of the joints"""
@@ -4968,74 +5416,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
@@ -5049,7 +5429,7 @@ class OnRobot2FG14GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot2FG14GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot2FG14GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5125,7 +5505,7 @@ class OnRobot2FG7GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot2FG7GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot2FG7GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5201,7 +5581,7 @@ class OnRobot3FG15GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot3FG15GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot3FG15GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5732,6 +6112,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 ActiveCalibrationContainer:
+  """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 ActiveCalibrationContainer, 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_container(data: object):
+  return ActiveCalibrationContainer(
+    calibrationData=parse_calibration_data(data["calibrationData"]) if "calibrationData" in data and data.get("calibrationData") is not None else None,
+  )
+
+def serialize_active_calibration_container(data: ActiveCalibrationContainer) -> 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
@@ -5875,7 +6285,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]:
@@ -5914,12 +6324,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, ""]
 
@@ -5946,7 +6356,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)
@@ -5959,7 +6369,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,
   )
 
@@ -5969,7 +6379,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),
   }