standardbots 2.0.0.dev1760378411__py3-none-any.whl → 2.0.0.dev1768505129__py3-none-any.whl

standardbots/auto_generated/models.py

@@ -240,6 +240,66 @@ 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 BoltHeadPosition:
+  """Bolt head position in pitch, yaw, roll"""
+  pitch: Union[float, None] = None
+  yaw: Union[float, None] = None
+  roll: Union[float, None] = None
+
+  def validate_pitch(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "pitch is required for BoltHeadPosition"]
+
+    if not isinstance(value, float):
+      return [False, "pitch must be of type float for BoltHeadPosition, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_yaw(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "yaw is required for BoltHeadPosition"]
+
+    if not isinstance(value, float):
+      return [False, "yaw must be of type float for BoltHeadPosition, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_roll(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "roll is required for BoltHeadPosition"]
+
+    if not isinstance(value, float):
+      return [False, "roll must be of type float for BoltHeadPosition, 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_pitch(self.pitch)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_yaw(self.yaw)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_roll(self.roll)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_bolt_head_position(data: object):
+  return BoltHeadPosition(
+    pitch=parse_f_64(data["pitch"]) if "pitch" in data and data.get("pitch") is not None else None,
+    yaw=parse_f_64(data["yaw"]) if "yaw" in data and data.get("yaw") is not None else None,
+    roll=parse_f_64(data["roll"]) if "roll" in data and data.get("roll") is not None else None,
+  )
+
+def serialize_bolt_head_position(data: BoltHeadPosition) -> object:
+  return {
+    "pitch": serialize_f_64(data.pitch),
+    "yaw": serialize_f_64(data.yaw),
+    "roll": serialize_f_64(data.roll),
+  }
+
 @dataclass
 class BotIdentityData:
   """Data about the robot's identity"""
@@ -387,6 +447,81 @@ def serialize_camera_configuration(data: CameraConfiguration) -> object:
     "height": None if data.height is None else serialize_u_32(data.height),
   }
 
+@dataclass
+class CameraFrameResponse:
+  """Response containing a camera frame and associated metadata."""
+  imageData: Union[str, None] = None
+  timestamp: Union[str, None] = None
+  camera_id: Union[str, None] = None
+  stream_name: Union[str, None] = None
+
+  def validate_imageData(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "imageData must be of type str for CameraFrameResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_timestamp(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "timestamp must be of type str for CameraFrameResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_camera_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "camera_id must be of type str for CameraFrameResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_stream_name(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "stream_name must be of type str for CameraFrameResponse, 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_imageData(self.imageData)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_timestamp(self.timestamp)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_camera_id(self.camera_id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_stream_name(self.stream_name)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_frame_response(data: object):
+  return CameraFrameResponse(
+    imageData=parse_str(data["imageData"]) if "imageData" in data and data.get("imageData") is not None else None,
+    timestamp=parse_str(data["timestamp"]) if "timestamp" in data and data.get("timestamp") is not None else None,
+    camera_id=parse_str(data["camera_id"]) if "camera_id" in data and data.get("camera_id") is not None else None,
+    stream_name=parse_str(data["stream_name"]) if "stream_name" in data and data.get("stream_name") is not None else None,
+  )
+
+def serialize_camera_frame_response(data: CameraFrameResponse) -> object:
+  return {
+    "imageData": None if data.imageData is None else serialize_str(data.imageData),
+    "timestamp": None if data.timestamp is None else serialize_str(data.timestamp),
+    "camera_id": None if data.camera_id is None else serialize_str(data.camera_id),
+    "stream_name": None if data.stream_name is None else serialize_str(data.stream_name),
+  }
+
 @dataclass
 class CameraIntrinsics:
   """Intrinsic parameters of the camera."""
@@ -1094,6 +1229,22 @@ def serialize_dhpgc_gripper_configuration(data: DHPGCGripperConfiguration) -> ob
     "diameter": serialize_f_64(data.diameter),
   }
 
+@dataclass
+class ElastokinConfig:
+  """Elastokinematic configuration parameters (arbitrary JSON object from Cognibotics)"""
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    pass
+
+def parse_elastokin_config(data: object):
+  return ElastokinConfig(
+  )
+
+def serialize_elastokin_config(data: ElastokinConfig) -> object:
+  return {
+  }
+
 @dataclass
 class EngageEmergencyStopRequest:
   """Engage Emergency Stop. This will immediately stop the robot and prevent it from moving until the robot is unbraked.
@@ -1337,6 +1488,8 @@ class ErrorEnum(Enum):
   """Cannot change ROS state"""
   IoSafeguardError = "io_safeguard_error"
   """Cannot change IO state because of safeguard"""
+  RobotOutOfComplianceBounds = "robot_out_of_compliance_bounds"
+  """Cannot initiate compliance control: Robot is outside compliance bounds"""
 
 def parse_error_enum(data: object) -> ErrorEnum:
   return ErrorEnum(data)
@@ -1470,6 +1623,51 @@ def parse_force_unit_kind(data: object) -> ForceUnitKind:
 def serialize_force_unit_kind(data: Union[ForceUnitKind, str]) -> object:
   return ForceUnitKind(data).value
 
+@dataclass
+class GripperBounds:
+  """Gripper bounds configuration"""
+  min: Union[float, None] = None
+  max: Union[float, None] = None
+
+  def validate_min(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "min is required for GripperBounds"]
+
+    if not isinstance(value, float):
+      return [False, "min must be of type float for GripperBounds, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "max is required for GripperBounds"]
+
+    if not isinstance(value, float):
+      return [False, "max must be of type float for GripperBounds, 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_min(self.min)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max(self.max)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_gripper_bounds(data: object):
+  return GripperBounds(
+    min=parse_f_64(data["min"]) if "min" in data and data.get("min") is not None else None,
+    max=parse_f_64(data["max"]) if "max" in data and data.get("max") is not None else None,
+  )
+
+def serialize_gripper_bounds(data: GripperBounds) -> object:
+  return {
+    "min": serialize_f_64(data.min),
+    "max": serialize_f_64(data.max),
+  }
+
 class GripperKindEnum(Enum):
   Onrobot2Fg7 = "onrobot_2fg7"
   """An OnRobot 2FG7 Gripper is connected"""
@@ -1487,6 +1685,10 @@ class GripperKindEnum(Enum):
   """A DH CGI Gripper is connected"""
   SchunkEgx = "schunk_egx"
   """A Schunk EGU / EGK Gripper is connected"""
+  Robotiq2F = "robotiq_2f"
+  """A Robotiq 2F parallel jaw gripper is connected"""
+  RobotiqEpick = "robotiq_epick"
+  """A Robotiq EPick vacuum gripper is connected"""
   NoneConnected = "none_connected"
   """No gripper is connected"""
 
@@ -1736,6 +1938,14 @@ def parse_max_joint_speeds(data: object) -> MaxJointSpeeds:
 def serialize_max_joint_speeds(data: MaxJointSpeeds) -> 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]),]
 
+MaxJointTorques = Tuple[float,float,float,float,float,float,]
+
+def parse_max_joint_torques(data: object) -> MaxJointTorques:
+  return (parse_f_64(data[0]),parse_f_64(data[1]),parse_f_64(data[2]),parse_f_64(data[3]),parse_f_64(data[4]),parse_f_64(data[5]),)
+
+def serialize_max_joint_torques(data: MaxJointTorques) -> 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]),]
+
 class MovementKindEnum(Enum):
   Joint = "joint"
   """Enum Joint = `joint`"""
@@ -2652,6 +2862,70 @@ 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 RobotFrame(Enum):
+  World = "world"
+  """Enum World = `world`"""
+  Tooltip = "tooltip"
+  """Enum Tooltip = `tooltip`"""
+
+def parse_robot_frame(data: object) -> RobotFrame:
+  return RobotFrame(data)
+
+def serialize_robot_frame(data: Union[RobotFrame, str]) -> object:
+  return RobotFrame(data).value
+
+class Robotiq2FControlKindEnum(Enum):
+  Move = "move"
+  """Move jaws to the requested position"""
+
+def parse_robotiq_2_f_control_kind_enum(data: object) -> Robotiq2FControlKindEnum:
+  return Robotiq2FControlKindEnum(data)
+
+def serialize_robotiq_2_f_control_kind_enum(data: Union[Robotiq2FControlKindEnum, str]) -> object:
+  return Robotiq2FControlKindEnum(data).value
+
+class RobotiqEPickControlKindEnum(Enum):
+  Grip = "grip"
+  """Grip with vacuum"""
+  Release = "release"
+  """Release vacuum"""
+
+def parse_robotiq_e_pick_control_kind_enum(data: object) -> RobotiqEPickControlKindEnum:
+  return RobotiqEPickControlKindEnum(data)
+
+def serialize_robotiq_e_pick_control_kind_enum(data: Union[RobotiqEPickControlKindEnum, str]) -> object:
+  return RobotiqEPickControlKindEnum(data).value
+
+@dataclass
+class RobotiqEPickGripperConfiguration:
+  """Configuration for Robotiq EPick vacuum gripper"""
+  mass_kg: Union[float, None] = None
+
+  def validate_mass_kg(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "mass_kg must be of type float for RobotiqEPickGripperConfiguration, 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_mass_kg(self.mass_kg)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_robotiq_e_pick_gripper_configuration(data: object):
+  return RobotiqEPickGripperConfiguration(
+    mass_kg=parse_f_64(data["mass_kg"]) if "mass_kg" in data and data.get("mass_kg") is not None else None,
+  )
+
+def serialize_robotiq_e_pick_gripper_configuration(data: RobotiqEPickGripperConfiguration) -> object:
+  return {
+    "mass_kg": None if data.mass_kg is None else serialize_f_64(data.mass_kg),
+  }
+
 class RobotStatusEnum(Enum):
   Idle = "Idle"
   """Enum Idle = `Idle`"""
@@ -3152,11 +3426,42 @@ def serialize_sensor_config(data: SensorConfig) -> object:
     "metadata": None if data.metadata is None else serialize_str(data.metadata),
   }
 
+@dataclass
+class SetFilterTypeRequest:
+  """Request to set filter type"""
+  filterType: Union[str, None] = None
+
+  def validate_filterType(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "filterType is required for SetFilterTypeRequest"]
+
+    if not isinstance(value, str):
+      return [False, "filterType must be of type str for SetFilterTypeRequest, 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_filterType(self.filterType)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_set_filter_type_request(data: object):
+  return SetFilterTypeRequest(
+    filterType=parse_str(data["filterType"]) if "filterType" in data and data.get("filterType") is not None else None,
+  )
+
+def serialize_set_filter_type_request(data: SetFilterTypeRequest) -> object:
+  return {
+    "filterType": serialize_str(data.filterType),
+  }
+
 @dataclass
 class SetRatioControlRequest:
   """Request to set ratio control parameters"""
   enabled: Union[bool, None] = None
-  value: Union[float, None] = None
+  movementValue: Union[float, None] = None
+  rotationValue: Union[float, None] = None
 
   def validate_enabled(self, value: bool) -> Tuple[bool, str]:
     if value is None:
@@ -3167,12 +3472,21 @@ class SetRatioControlRequest:
 
     return [True, ""]
 
-  def validate_value(self, value: float) -> Tuple[bool, str]:
+  def validate_movementValue(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "movementValue must be of type float for SetRatioControlRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_rotationValue(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 SetRatioControlRequest, got " + type(value).__name__]
+      return [False, "rotationValue must be of type float for SetRatioControlRequest, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -3181,20 +3495,25 @@ class SetRatioControlRequest:
     is_valid, error_str = self.validate_enabled(self.enabled)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_value(self.value)
+    is_valid, error_str = self.validate_movementValue(self.movementValue)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_rotationValue(self.rotationValue)
     if not is_valid:
       raise TypeError(error_str)
 
 def parse_set_ratio_control_request(data: object):
   return SetRatioControlRequest(
     enabled=parse_bool(data["enabled"]) if "enabled" in data and data.get("enabled") is not None else None,
-    value=parse_f_64(data["value"]) if "value" in data and data.get("value") is not None else None,
+    movementValue=parse_f_64(data["movementValue"]) if "movementValue" in data and data.get("movementValue") is not None else None,
+    rotationValue=parse_f_64(data["rotationValue"]) if "rotationValue" in data and data.get("rotationValue") is not None else None,
   )
 
 def serialize_set_ratio_control_request(data: SetRatioControlRequest) -> object:
   return {
     "enabled": None if data.enabled is None else serialize_bool(data.enabled),
-    "value": None if data.value is None else serialize_f_64(data.value),
+    "movementValue": None if data.movementValue is None else serialize_f_64(data.movementValue),
+    "rotationValue": None if data.rotationValue is None else serialize_f_64(data.rotationValue),
   }
 
 class SignalMessageType(Enum):
@@ -3318,42 +3637,80 @@ def serialize_status_version_data(data: StatusVersionData) -> object:
     "name": None if data.name is None else serialize_str(data.name),
   }
 
+StringArray = List[str]
+
+def parse_string_array(data: object) -> StringArray:
+  return [parse_str(item) for item in data]
+
+def serialize_string_array(data: StringArray) -> List[object]:
+  return [serialize_str(item) for item in data]
+
 @dataclass
-class StopRecordingRequest:
-  """Request to stop recording movement and camera data"""
-  delete: Union[bool, None] = None
+class TeleopClient:
+  """Connected teleop client"""
+  clientId: Union[str, None] = None
+  clientType: Union[str, None] = None
+  connectedAt: Union[str, None] = None
 
-  def validate_delete(self, value: bool) -> Tuple[bool, str]:
+  def validate_clientId(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "delete must be of type bool for StopRecordingRequest, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "clientId must be of type str for TeleopClient, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_clientType(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "clientType must be of type str for TeleopClient, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_connectedAt(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "connectedAt must be of type str for TeleopClient, 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_delete(self.delete)
+    is_valid, error_str = self.validate_clientId(self.clientId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_clientType(self.clientType)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_connectedAt(self.connectedAt)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_stop_recording_request(data: object):
-  return StopRecordingRequest(
-    delete=parse_bool(data["delete"]) if "delete" in data and data.get("delete") is not None else None,
+def parse_teleop_client(data: object):
+  return TeleopClient(
+    clientId=parse_str(data["clientId"]) if "clientId" in data and data.get("clientId") is not None else None,
+    clientType=parse_str(data["clientType"]) if "clientType" in data and data.get("clientType") is not None else None,
+    connectedAt=parse_str(data["connectedAt"]) if "connectedAt" in data and data.get("connectedAt") is not None else None,
   )
 
-def serialize_stop_recording_request(data: StopRecordingRequest) -> object:
+def serialize_teleop_client(data: TeleopClient) -> object:
   return {
-    "delete": None if data.delete is None else serialize_bool(data.delete),
+    "clientId": None if data.clientId is None else serialize_str(data.clientId),
+    "clientType": None if data.clientType is None else serialize_str(data.clientType),
+    "connectedAt": None if data.connectedAt is None else serialize_str(data.connectedAt),
   }
 
-StringArray = List[str]
+TeleopErrorArray = List[str]
 
-def parse_string_array(data: object) -> StringArray:
+def parse_teleop_error_array(data: object) -> TeleopErrorArray:
   return [parse_str(item) for item in data]
 
-def serialize_string_array(data: StringArray) -> List[object]:
+def serialize_teleop_error_array(data: TeleopErrorArray) -> List[object]:
   return [serialize_str(item) for item in data]
 
 class TeleopStatus(Enum):
@@ -3668,6 +4025,36 @@ def parse_arm_position_update_request_response_event_stream_subscriptions_list(d
 def serialize_arm_position_update_request_response_event_stream_subscriptions_list(data: ArmPositionUpdateRequestResponseEventStreamSubscriptionsList) -> List[object]:
   return [serialize_arm_position_update_request_response_event_stream_subscription_kind_enum(item) for item in data]
 
+@dataclass
+class SetBoltHeadPositionRequest:
+  """Request to set static bolt head position"""
+  position: Union[BoltHeadPosition, None] = None
+
+  def validate_position(self, value: BoltHeadPosition) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "position is required for SetBoltHeadPositionRequest"]
+
+    if not isinstance(value, BoltHeadPosition):
+      return [False, "position must be of type BoltHeadPosition for SetBoltHeadPositionRequest, 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_position(self.position)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_set_bolt_head_position_request(data: object):
+  return SetBoltHeadPositionRequest(
+    position=parse_bolt_head_position(data["position"]) if "position" in data and data.get("position") is not None else None,
+  )
+
+def serialize_set_bolt_head_position_request(data: SetBoltHeadPositionRequest) -> object:
+  return {
+    "position": serialize_bolt_head_position(data.position),
+  }
+
 @dataclass
 class BrakesState:
   """State of the robot joint brakes. Each joint contains a brake which can be engaged when the robot is at a standstill to prevent the robot from moving.
@@ -4211,7 +4598,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', 'invalid_parameters', 'routine_does_not_exist', 'cannot_play_routine', 'routine_must_be_playing', 'cannot_change_ros_state', 'io_safeguard_error']) 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', 'robot_out_of_compliance_bounds']) or isinstance(value, ErrorEnum)):
       return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
@@ -4548,12 +4935,24 @@ def serialize_force_unit(data: ForceUnit) -> object:
     "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
+SecondaryBotGripperBounds = Dict[str, GripperBounds]
 
-  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
+def parse_secondary_bot_gripper_bounds(data: object) -> SecondaryBotGripperBounds:
+  return {
+    parse_str(key): parse_gripper_bounds(value) for key, value in data.items()
+  }
+
+def serialize_secondary_bot_gripper_bounds(data: SecondaryBotGripperBounds) -> object:
+  return {
+    serialize_str(key): serialize_gripper_bounds(value) for key, value in data.items()
+  }
+
+@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, ""]
 
@@ -4901,6 +5300,7 @@ class SpeedProfile:
   max_joint_speeds: Union[MaxJointSpeeds, None] = None
   max_joint_accelerations: Union[MaxJointAcclerations, None] = None
   max_tooltip_speed: Union[float, None] = None
+  max_joint_torques: Union[MaxJointTorques, None] = None
   base_acceleration_scaling: Union[float, None] = None
   base_velocity_scaling: Union[float, None] = None
   scaling_factor: Union[float, None] = None
@@ -4932,6 +5332,15 @@ class SpeedProfile:
 
     return [True, ""]
 
+  def validate_max_joint_torques(self, value: MaxJointTorques) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, tuple) and len(value) == 6):
+      return [False, "max_joint_torques must be of type MaxJointTorques 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, ""]
@@ -4968,6 +5377,9 @@ class SpeedProfile:
     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_max_joint_torques(self.max_joint_torques)
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_base_acceleration_scaling(self.base_acceleration_scaling)
@@ -4985,6 +5397,7 @@ def parse_speed_profile(data: object):
     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,
+    max_joint_torques=parse_max_joint_torques(data["max_joint_torques"]) if "max_joint_torques" in data and data.get("max_joint_torques") 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,
@@ -4995,6 +5408,7 @@ def serialize_speed_profile(data: SpeedProfile) -> object:
     "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),
+    "max_joint_torques": None if data.max_joint_torques is None else serialize_max_joint_torques(data.max_joint_torques),
     "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),
@@ -6036,6 +6450,124 @@ def serialize_robot_control_mode(data: RobotControlMode) -> object:
     "kind": None if data.kind is None else serialize_robot_control_mode_enum(data.kind),
   }
 
+SecondaryBotRobotFrame = Dict[str, RobotFrame]
+
+def parse_secondary_bot_robot_frame(data: object) -> SecondaryBotRobotFrame:
+  return {
+    parse_str(key): parse_robot_frame(value) for key, value in data.items()
+  }
+
+def serialize_secondary_bot_robot_frame(data: SecondaryBotRobotFrame) -> object:
+  return {
+    serialize_str(key): serialize_robot_frame(value) for key, value in data.items()
+  }
+
+@dataclass
+class RobotiqEPickGripperCommandRequest:
+  """Control the Robotiq EPick vacuum gripper
+"""
+  control_kind: Union[RobotiqEPickControlKindEnum, None] = None
+  mode: Union[str, None] = None
+  target_force_percent: Union[float, None] = None
+  min_force_percent: Union[float, None] = None
+  timeout_ms: Union[float, None] = None
+  blow_off_pressure_percent: Union[float, None] = None
+
+  def validate_control_kind(self, value: RobotiqEPickControlKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "control_kind is required for RobotiqEPickGripperCommandRequest"]
+
+    if not ((isinstance(value, str) and RobotiqEPickControlKindEnum in ['grip', 'release']) or isinstance(value, RobotiqEPickControlKindEnum)):
+      return [False, "control_kind must be of type RobotiqEPickControlKindEnum for RobotiqEPickGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_mode(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "mode must be of type str for RobotiqEPickGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_force_percent(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "target_force_percent must be of type float for RobotiqEPickGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_min_force_percent(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "min_force_percent must be of type float for RobotiqEPickGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_timeout_ms(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "timeout_ms must be of type float for RobotiqEPickGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_blow_off_pressure_percent(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "blow_off_pressure_percent must be of type float for RobotiqEPickGripperCommandRequest, 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_control_kind(self.control_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_mode(self.mode)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_target_force_percent(self.target_force_percent)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_min_force_percent(self.min_force_percent)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_timeout_ms(self.timeout_ms)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_blow_off_pressure_percent(self.blow_off_pressure_percent)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_robotiq_e_pick_gripper_command_request(data: object):
+  return RobotiqEPickGripperCommandRequest(
+    control_kind=parse_robotiq_e_pick_control_kind_enum(data["control_kind"]) if "control_kind" in data and data.get("control_kind") is not None else None,
+    mode=parse_str(data["mode"]) if "mode" in data and data.get("mode") is not None else None,
+    target_force_percent=parse_f_64(data["target_force_percent"]) if "target_force_percent" in data and data.get("target_force_percent") is not None else None,
+    min_force_percent=parse_f_64(data["min_force_percent"]) if "min_force_percent" in data and data.get("min_force_percent") is not None else None,
+    timeout_ms=parse_f_64(data["timeout_ms"]) if "timeout_ms" in data and data.get("timeout_ms") is not None else None,
+    blow_off_pressure_percent=parse_f_64(data["blow_off_pressure_percent"]) if "blow_off_pressure_percent" in data and data.get("blow_off_pressure_percent") is not None else None,
+  )
+
+def serialize_robotiq_e_pick_gripper_command_request(data: RobotiqEPickGripperCommandRequest) -> object:
+  return {
+    "control_kind": serialize_robotiq_e_pick_control_kind_enum(data.control_kind),
+    "mode": None if data.mode is None else serialize_str(data.mode),
+    "target_force_percent": None if data.target_force_percent is None else serialize_f_64(data.target_force_percent),
+    "min_force_percent": None if data.min_force_percent is None else serialize_f_64(data.min_force_percent),
+    "timeout_ms": None if data.timeout_ms is None else serialize_f_64(data.timeout_ms),
+    "blow_off_pressure_percent": None if data.blow_off_pressure_percent is None else serialize_f_64(data.blow_off_pressure_percent),
+  }
+
 @dataclass
 class PlayRoutineResponse:
   """Status response informs user of of robot state"""
@@ -6547,6 +7079,59 @@ def serialize_save_recording_response(data: SaveRecordingResponse) -> object:
     "errors": None if data.errors is None else serialize_string_array(data.errors),
   }
 
+@dataclass
+class StopRecordingRequest:
+  """Request to stop recording movement and camera data"""
+  delete: Union[bool, None] = None
+  tags: Union[StringArray, None] = None
+
+  def validate_delete(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "delete must be of type bool for StopRecordingRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_tags(self, value: StringArray) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, str) for x in value)):
+      return [False, "tags must be of type StringArray for StopRecordingRequest, 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_delete(self.delete)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_tags(self.tags)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_stop_recording_request(data: object):
+  return StopRecordingRequest(
+    delete=parse_bool(data["delete"]) if "delete" in data and data.get("delete") is not None else None,
+    tags=parse_string_array(data["tags"]) if "tags" in data and data.get("tags") is not None else None,
+  )
+
+def serialize_stop_recording_request(data: StopRecordingRequest) -> object:
+  return {
+    "delete": None if data.delete is None else serialize_bool(data.delete),
+    "tags": None if data.tags is None else serialize_string_array(data.tags),
+  }
+
+TeleopClientList = List[TeleopClient]
+
+def parse_teleop_client_list(data: object) -> TeleopClientList:
+  return [parse_teleop_client(item) for item in data]
+
+def serialize_teleop_client_list(data: TeleopClientList) -> List[object]:
+  return [serialize_teleop_client(item) for item in data]
+
 @dataclass
 class BotTeleopDetails:
   """Details of the bot"""
@@ -6557,6 +7142,11 @@ class BotTeleopDetails:
   isSecondary: Union[bool, None] = None
   isEnabled: Union[bool, None] = None
   status: Union[TeleopStatus, None] = None
+  errors: Union[TeleopErrorArray, None] = None
+  gripperBounds: Union[GripperBounds, None] = None
+  robotFrame: Union[RobotFrame, None] = None
+  filterType: Union[str, None] = None
+  activeClientId: Union[str, None] = None
 
   def validate_botId(self, value: str) -> Tuple[bool, str]:
     if value is None:
@@ -6621,6 +7211,51 @@ class BotTeleopDetails:
 
     return [True, ""]
 
+  def validate_errors(self, value: TeleopErrorArray) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, str) for x in value)):
+      return [False, "errors must be of type TeleopErrorArray for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_gripperBounds(self, value: GripperBounds) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, GripperBounds):
+      return [False, "gripperBounds must be of type GripperBounds for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_robotFrame(self, value: RobotFrame) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RobotFrame in ['world', 'tooltip']) or isinstance(value, RobotFrame)):
+      return [False, "robotFrame must be of type RobotFrame for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_filterType(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "filterType must be of type str for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_activeClientId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "activeClientId must be of type str for BotTeleopDetails, 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_botId(self.botId)
@@ -6644,6 +7279,21 @@ class BotTeleopDetails:
     is_valid, error_str = self.validate_status(self.status)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_errors(self.errors)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_gripperBounds(self.gripperBounds)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotFrame(self.robotFrame)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_filterType(self.filterType)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_activeClientId(self.activeClientId)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_bot_teleop_details(data: object):
   return BotTeleopDetails(
@@ -6654,6 +7304,11 @@ def parse_bot_teleop_details(data: object):
     isSecondary=parse_bool(data["isSecondary"]) if "isSecondary" in data and data.get("isSecondary") is not None else None,
     isEnabled=parse_bool(data["isEnabled"]) if "isEnabled" in data and data.get("isEnabled") is not None else None,
     status=parse_teleop_status(data["status"]) if "status" in data and data.get("status") is not None else None,
+    errors=parse_teleop_error_array(data["errors"]) if "errors" in data and data.get("errors") is not None else None,
+    gripperBounds=parse_gripper_bounds(data["gripperBounds"]) if "gripperBounds" in data and data.get("gripperBounds") is not None else None,
+    robotFrame=parse_robot_frame(data["robotFrame"]) if "robotFrame" in data and data.get("robotFrame") is not None else None,
+    filterType=parse_str(data["filterType"]) if "filterType" in data and data.get("filterType") is not None else None,
+    activeClientId=parse_str(data["activeClientId"]) if "activeClientId" in data and data.get("activeClientId") is not None else None,
   )
 
 def serialize_bot_teleop_details(data: BotTeleopDetails) -> object:
@@ -6665,6 +7320,11 @@ def serialize_bot_teleop_details(data: BotTeleopDetails) -> object:
     "isSecondary": None if data.isSecondary is None else serialize_bool(data.isSecondary),
     "isEnabled": None if data.isEnabled is None else serialize_bool(data.isEnabled),
     "status": None if data.status is None else serialize_teleop_status(data.status),
+    "errors": None if data.errors is None else serialize_teleop_error_array(data.errors),
+    "gripperBounds": None if data.gripperBounds is None else serialize_gripper_bounds(data.gripperBounds),
+    "robotFrame": None if data.robotFrame is None else serialize_robot_frame(data.robotFrame),
+    "filterType": None if data.filterType is None else serialize_str(data.filterType),
+    "activeClientId": None if data.activeClientId is None else serialize_str(data.activeClientId),
   }
 
 @dataclass
@@ -6803,6 +7463,7 @@ class CalibrationData:
   timestamp: Union[str, None] = None
   armSerial: Union[str, None] = None
   urdfParameters: Union[URDFParameters, None] = None
+  elastokinConfig: Union[ElastokinConfig, None] = None
 
   def validate_timestamp(self, value: str) -> Tuple[bool, str]:
     if value is None:
@@ -6831,6 +7492,15 @@ class CalibrationData:
 
     return [True, ""]
 
+  def validate_elastokinConfig(self, value: ElastokinConfig) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, ElastokinConfig):
+      return [False, "elastokinConfig must be of type ElastokinConfig 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)
@@ -6842,12 +7512,16 @@ class CalibrationData:
     is_valid, error_str = self.validate_urdfParameters(self.urdfParameters)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_elastokinConfig(self.elastokinConfig)
+    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,
+    elastokinConfig=parse_elastokin_config(data["elastokinConfig"]) if "elastokinConfig" in data and data.get("elastokinConfig") is not None else None,
   )
 
 def serialize_calibration_data(data: CalibrationData) -> object:
@@ -6855,6 +7529,52 @@ def serialize_calibration_data(data: CalibrationData) -> object:
     "timestamp": serialize_str(data.timestamp),
     "armSerial": serialize_str(data.armSerial),
     "urdfParameters": serialize_urdf_parameters(data.urdfParameters),
+    "elastokinConfig": None if data.elastokinConfig is None else serialize_elastokin_config(data.elastokinConfig),
+  }
+
+@dataclass
+class SetGripperBoundsRequest:
+  """Request to set gripper bounds for primary and secondary bots"""
+  primary: Union[GripperBounds, None] = None
+  secondary: Union[SecondaryBotGripperBounds, None] = None
+
+  def validate_primary(self, value: GripperBounds) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "primary is required for SetGripperBoundsRequest"]
+
+    if not isinstance(value, GripperBounds):
+      return [False, "primary must be of type GripperBounds for SetGripperBoundsRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_secondary(self, value: SecondaryBotGripperBounds) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, GripperBounds)) for k, val in value.items())):
+      return [False, "secondary must be of type SecondaryBotGripperBounds for SetGripperBoundsRequest, 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_primary(self.primary)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_secondary(self.secondary)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_set_gripper_bounds_request(data: object):
+  return SetGripperBoundsRequest(
+    primary=parse_gripper_bounds(data["primary"]) if "primary" in data and data.get("primary") is not None else None,
+    secondary=parse_secondary_bot_gripper_bounds(data["secondary"]) if "secondary" in data and data.get("secondary") is not None else None,
+  )
+
+def serialize_set_gripper_bounds_request(data: SetGripperBoundsRequest) -> object:
+  return {
+    "primary": serialize_gripper_bounds(data.primary),
+    "secondary": None if data.secondary is None else serialize_secondary_bot_gripper_bounds(data.secondary),
   }
 
 ArmJointRotationsList = List[ArmJointRotations]
@@ -7199,229 +7919,230 @@ def serialize_on_robot_3_fg_15_gripper_command_request(data: OnRobot3FG15Gripper
   }
 
 @dataclass
-class SchunkEGxGripperCommandRequest:
-  """Control the Schunk EGU / EGK  gripper (end effector) of the robot
+class Robotiq2FGripperCommandRequest:
+  """Control the Robotiq 2F parallel jaw gripper (2F-85 / 2F-140)
 """
+  control_kind: Union[Robotiq2FControlKindEnum, None] = None
   target_grip_width: Union[LinearUnit, None] = None
-  control_kind: Union[SchunkEGxControlKindEnum, None] = None
+  target_speed: Union[float, None] = None
+  target_force: Union[ForceUnit, None] = None
+
+  def validate_control_kind(self, value: Robotiq2FControlKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "control_kind is required for Robotiq2FGripperCommandRequest"]
+
+    if not ((isinstance(value, str) and Robotiq2FControlKindEnum in ['move']) or isinstance(value, Robotiq2FControlKindEnum)):
+      return [False, "control_kind must be of type Robotiq2FControlKindEnum for Robotiq2FGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
 
   def validate_target_grip_width(self, value: LinearUnit) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "target_grip_width is required for Robotiq2FGripperCommandRequest"]
 
     if not isinstance(value, LinearUnit):
-      return [False, "target_grip_width must be of type LinearUnit for SchunkEGxGripperCommandRequest, got " + type(value).__name__]
+      return [False, "target_grip_width must be of type LinearUnit for Robotiq2FGripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_control_kind(self, value: SchunkEGxControlKindEnum) -> Tuple[bool, str]:
+  def validate_target_speed(self, value: float) -> Tuple[bool, str]:
     if value is None:
-      return [False, "control_kind is required for SchunkEGxGripperCommandRequest"]
+      return [False, "target_speed is required for Robotiq2FGripperCommandRequest"]
 
-    if not ((isinstance(value, str) and SchunkEGxControlKindEnum in ['move']) or isinstance(value, SchunkEGxControlKindEnum)):
-      return [False, "control_kind must be of type SchunkEGxControlKindEnum for SchunkEGxGripperCommandRequest, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "target_speed must be of type float for Robotiq2FGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_force(self, value: ForceUnit) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "target_force is required for Robotiq2FGripperCommandRequest"]
+
+    if not isinstance(value, ForceUnit):
+      return [False, "target_force must be of type ForceUnit for Robotiq2FGripperCommandRequest, 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_control_kind(self.control_kind)
+    if not is_valid:
+      raise TypeError(error_str)
     is_valid, error_str = self.validate_target_grip_width(self.target_grip_width)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_control_kind(self.control_kind)
+    is_valid, error_str = self.validate_target_speed(self.target_speed)
+    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)
 
-def parse_schunk_e_gx_gripper_command_request(data: object):
-  return SchunkEGxGripperCommandRequest(
+def parse_robotiq_2_f_gripper_command_request(data: object):
+  return Robotiq2FGripperCommandRequest(
+    control_kind=parse_robotiq_2_f_control_kind_enum(data["control_kind"]) if "control_kind" in data and data.get("control_kind") is not None else None,
     target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data and data.get("target_grip_width") is not None else None,
-    control_kind=parse_schunk_e_gx_control_kind_enum(data["control_kind"]) if "control_kind" in data and data.get("control_kind") is not None else None,
+    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data and data.get("target_speed") is not None else None,
+    target_force=parse_force_unit(data["target_force"]) if "target_force" in data and data.get("target_force") is not None else None,
   )
 
-def serialize_schunk_e_gx_gripper_command_request(data: SchunkEGxGripperCommandRequest) -> object:
+def serialize_robotiq_2_f_gripper_command_request(data: Robotiq2FGripperCommandRequest) -> object:
   return {
-    "target_grip_width": None if data.target_grip_width is None else serialize_linear_unit(data.target_grip_width),
-    "control_kind": serialize_schunk_e_gx_control_kind_enum(data.control_kind),
+    "control_kind": serialize_robotiq_2_f_control_kind_enum(data.control_kind),
+    "target_grip_width": serialize_linear_unit(data.target_grip_width),
+    "target_speed": serialize_f_64(data.target_speed),
+    "target_force": serialize_force_unit(data.target_force),
   }
 
 @dataclass
-class OffsetConfig:
-  """Config of the offset"""
-  position: Union[Position, None] = None
-  orientation: Union[Quaternion, None] = None
+class Robotiq2FGripperConfiguration:
+  """Configuration for Robotiq 2F grippers (2F-85 / 2F-140)"""
+  model_variant: Union[str, None] = None
+  min_grip_width: Union[LinearUnit, None] = None
+  max_grip_width: Union[LinearUnit, None] = None
 
-  def validate_position(self, value: Position) -> Tuple[bool, str]:
+  def validate_model_variant(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, Position):
-      return [False, "position must be of type Position for OffsetConfig, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "model_variant must be of type str for Robotiq2FGripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_orientation(self, value: Quaternion) -> Tuple[bool, str]:
+  def validate_min_grip_width(self, value: LinearUnit) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, Quaternion):
-      return [False, "orientation must be of type Quaternion for OffsetConfig, got " + type(value).__name__]
+    if not isinstance(value, LinearUnit):
+      return [False, "min_grip_width must be of type LinearUnit for Robotiq2FGripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_max_grip_width(self, value: LinearUnit) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, LinearUnit):
+      return [False, "max_grip_width must be of type LinearUnit for Robotiq2FGripperConfiguration, 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_position(self.position)
+    is_valid, error_str = self.validate_model_variant(self.model_variant)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_orientation(self.orientation)
+    is_valid, error_str = self.validate_min_grip_width(self.min_grip_width)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_max_grip_width(self.max_grip_width)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_offset_config(data: object):
-  return OffsetConfig(
-    position=parse_position(data["position"]) if "position" in data and data.get("position") is not None else None,
-    orientation=parse_quaternion(data["orientation"]) if "orientation" in data and data.get("orientation") is not None else None,
+def parse_robotiq_2_f_gripper_configuration(data: object):
+  return Robotiq2FGripperConfiguration(
+    model_variant=parse_str(data["model_variant"]) if "model_variant" in data and data.get("model_variant") is not None else None,
+    min_grip_width=parse_linear_unit(data["min_grip_width"]) if "min_grip_width" in data and data.get("min_grip_width") is not None else None,
+    max_grip_width=parse_linear_unit(data["max_grip_width"]) if "max_grip_width" in data and data.get("max_grip_width") is not None else None,
   )
 
-def serialize_offset_config(data: OffsetConfig) -> object:
+def serialize_robotiq_2_f_gripper_configuration(data: Robotiq2FGripperConfiguration) -> object:
   return {
-    "position": None if data.position is None else serialize_position(data.position),
-    "orientation": None if data.orientation is None else serialize_quaternion(data.orientation),
+    "model_variant": None if data.model_variant is None else serialize_str(data.model_variant),
+    "min_grip_width": None if data.min_grip_width is None else serialize_linear_unit(data.min_grip_width),
+    "max_grip_width": None if data.max_grip_width is None else serialize_linear_unit(data.max_grip_width),
   }
 
 @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, ""]
+class SchunkEGxGripperCommandRequest:
+  """Control the Schunk EGU / EGK  gripper (end effector) of the robot
+"""
+  target_grip_width: Union[LinearUnit, None] = None
+  control_kind: Union[SchunkEGxControlKindEnum, None] = None
 
-  def validate_onrobot_2fg14(self, value: OnRobot2FG14GripperConfiguration) -> Tuple[bool, str]:
+  def validate_target_grip_width(self, value: LinearUnit) -> 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__]
+    if not isinstance(value, LinearUnit):
+      return [False, "target_grip_width must be of type LinearUnit for SchunkEGxGripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_onrobot_3fg15(self, value: OnRobot3FG15GripperConfiguration) -> Tuple[bool, str]:
+  def validate_control_kind(self, value: SchunkEGxControlKindEnum) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "control_kind is required for SchunkEGxGripperCommandRequest"]
 
-    if not isinstance(value, OnRobot3FG15GripperConfiguration):
-      return [False, "onrobot_3fg15 must be of type OnRobot3FG15GripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+    if not ((isinstance(value, str) and SchunkEGxControlKindEnum in ['move']) or isinstance(value, SchunkEGxControlKindEnum)):
+      return [False, "control_kind must be of type SchunkEGxControlKindEnum for SchunkEGxGripperCommandRequest, 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 __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_target_grip_width(self.target_grip_width)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_control_kind(self.control_kind)
+    if not is_valid:
+      raise TypeError(error_str)
 
-  def validate_dh_ag(self, value: DHAGGripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_schunk_e_gx_gripper_command_request(data: object):
+  return SchunkEGxGripperCommandRequest(
+    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data and data.get("target_grip_width") is not None else None,
+    control_kind=parse_schunk_e_gx_control_kind_enum(data["control_kind"]) if "control_kind" in data and data.get("control_kind") is not None else None,
+  )
 
-    if not isinstance(value, DHAGGripperConfiguration):
-      return [False, "dh_ag must be of type DHAGGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+def serialize_schunk_e_gx_gripper_command_request(data: SchunkEGxGripperCommandRequest) -> object:
+  return {
+    "target_grip_width": None if data.target_grip_width is None else serialize_linear_unit(data.target_grip_width),
+    "control_kind": serialize_schunk_e_gx_control_kind_enum(data.control_kind),
+  }
 
-    return [True, ""]
+@dataclass
+class OffsetConfig:
+  """Config of the offset"""
+  position: Union[Position, None] = None
+  orientation: Union[Quaternion, None] = None
 
-  def validate_dh_pgc(self, value: DHPGCGripperConfiguration) -> Tuple[bool, str]:
+  def validate_position(self, value: Position) -> 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__]
+    if not isinstance(value, Position):
+      return [False, "position must be of type Position for OffsetConfig, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_dh_cgi(self, value: DHCGIGripperConfiguration) -> Tuple[bool, str]:
+  def validate_orientation(self, value: Quaternion) -> 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__]
+    if not isinstance(value, Quaternion):
+      return [False, "orientation must be of type Quaternion for OffsetConfig, 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)
+    is_valid, error_str = self.validate_position(self.position)
     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_orientation(self.orientation)
     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 parse_offset_config(data: object):
+  return OffsetConfig(
+    position=parse_position(data["position"]) if "position" in data and data.get("position") is not None else None,
+    orientation=parse_quaternion(data["orientation"]) if "orientation" in data and data.get("orientation") is not None else None,
   )
 
-def serialize_gripper_configuration(data: GripperConfiguration) -> object:
+def serialize_offset_config(data: OffsetConfig) -> 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),
+    "position": None if data.position is None else serialize_position(data.position),
+    "orientation": None if data.orientation is None else serialize_quaternion(data.orientation),
   }
 
 @dataclass
@@ -7627,6 +8348,51 @@ def serialize_failure_state_response(data: FailureStateResponse) -> object:
     "failure": None if data.failure is None else serialize_failure_state_details(data.failure),
   }
 
+@dataclass
+class SetRobotFrameRequest:
+  """Request to set robot frame"""
+  primary: Union[RobotFrame, None] = None
+  secondary: Union[SecondaryBotRobotFrame, None] = None
+
+  def validate_primary(self, value: RobotFrame) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "primary is required for SetRobotFrameRequest"]
+
+    if not ((isinstance(value, str) and RobotFrame in ['world', 'tooltip']) or isinstance(value, RobotFrame)):
+      return [False, "primary must be of type RobotFrame for SetRobotFrameRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_secondary(self, value: SecondaryBotRobotFrame) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and ((isinstance(val, str) and RobotFrame in ['world', 'tooltip']) or isinstance(val, RobotFrame))) for k, val in value.items())):
+      return [False, "secondary must be of type SecondaryBotRobotFrame for SetRobotFrameRequest, 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_primary(self.primary)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_secondary(self.secondary)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_set_robot_frame_request(data: object):
+  return SetRobotFrameRequest(
+    primary=parse_robot_frame(data["primary"]) if "primary" in data and data.get("primary") is not None else None,
+    secondary=parse_secondary_bot_robot_frame(data["secondary"]) if "secondary" in data and data.get("secondary") is not None else None,
+  )
+
+def serialize_set_robot_frame_request(data: SetRobotFrameRequest) -> object:
+  return {
+    "primary": serialize_robot_frame(data.primary),
+    "secondary": None if data.secondary is None else serialize_secondary_bot_robot_frame(data.secondary),
+  }
+
 @dataclass
 class SensorsConfiguration:
   """Configuration of all sensors defined in custom equipment"""
@@ -7855,6 +8621,171 @@ def serialize_active_calibration_container(data: ActiveCalibrationContainer) ->
     "calibrationData": None if data.calibrationData is None else serialize_calibration_data(data.calibrationData),
   }
 
+@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
+  robotiq_2f: Union[Robotiq2FGripperConfiguration, None] = None
+  robotiq_epick: Union[RobotiqEPickGripperConfiguration, 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', 'robotiq_2f', 'robotiq_epick', '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 validate_robotiq_2f(self, value: Robotiq2FGripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, Robotiq2FGripperConfiguration):
+      return [False, "robotiq_2f must be of type Robotiq2FGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_robotiq_epick(self, value: RobotiqEPickGripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, RobotiqEPickGripperConfiguration):
+      return [False, "robotiq_epick must be of type RobotiqEPickGripperConfiguration 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)
+    is_valid, error_str = self.validate_robotiq_2f(self.robotiq_2f)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotiq_epick(self.robotiq_epick)
+    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,
+    robotiq_2f=parse_robotiq_2_f_gripper_configuration(data["robotiq_2f"]) if "robotiq_2f" in data and data.get("robotiq_2f") is not None else None,
+    robotiq_epick=parse_robotiq_e_pick_gripper_configuration(data["robotiq_epick"]) if "robotiq_epick" in data and data.get("robotiq_epick") 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),
+    "robotiq_2f": None if data.robotiq_2f is None else serialize_robotiq_2_f_gripper_configuration(data.robotiq_2f),
+    "robotiq_epick": None if data.robotiq_epick is None else serialize_robotiq_e_pick_gripper_configuration(data.robotiq_epick),
+  }
+
 @dataclass
 class GripperCommandRequest:
   """Control the gripper (end effector) of the robot
@@ -7867,12 +8798,14 @@ class GripperCommandRequest:
   dh_pgc: Union[DHPGCGripperCommandRequest, None] = None
   dh_cgi: Union[DHCGIGripperCommandRequest, None] = None
   schunk_egx: Union[SchunkEGxGripperCommandRequest, None] = None
+  robotiq_2f: Union[Robotiq2FGripperCommandRequest, None] = None
+  robotiq_epick: Union[RobotiqEPickGripperCommandRequest, None] = None
 
   def validate_kind(self, value: GripperKindEnum) -> Tuple[bool, str]:
     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', 'onrobot_screwdriver', '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', 'robotiq_2f', 'robotiq_epick', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -7940,6 +8873,24 @@ class GripperCommandRequest:
 
     return [True, ""]
 
+  def validate_robotiq_2f(self, value: Robotiq2FGripperCommandRequest) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, Robotiq2FGripperCommandRequest):
+      return [False, "robotiq_2f must be of type Robotiq2FGripperCommandRequest for GripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_robotiq_epick(self, value: RobotiqEPickGripperCommandRequest) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, RobotiqEPickGripperCommandRequest):
+      return [False, "robotiq_epick must be of type RobotiqEPickGripperCommandRequest for GripperCommandRequest, 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)
@@ -7966,6 +8917,12 @@ class GripperCommandRequest:
     is_valid, error_str = self.validate_schunk_egx(self.schunk_egx)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotiq_2f(self.robotiq_2f)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotiq_epick(self.robotiq_epick)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_gripper_command_request(data: object):
   return GripperCommandRequest(
@@ -7977,6 +8934,8 @@ def parse_gripper_command_request(data: object):
     dh_pgc=parse_dhpgc_gripper_command_request(data["dh_pgc"]) if "dh_pgc" in data and data.get("dh_pgc") is not None else None,
     dh_cgi=parse_dhcgi_gripper_command_request(data["dh_cgi"]) if "dh_cgi" in data and data.get("dh_cgi") is not None else None,
     schunk_egx=parse_schunk_e_gx_gripper_command_request(data["schunk_egx"]) if "schunk_egx" in data and data.get("schunk_egx") is not None else None,
+    robotiq_2f=parse_robotiq_2_f_gripper_command_request(data["robotiq_2f"]) if "robotiq_2f" in data and data.get("robotiq_2f") is not None else None,
+    robotiq_epick=parse_robotiq_e_pick_gripper_command_request(data["robotiq_epick"]) if "robotiq_epick" in data and data.get("robotiq_epick") is not None else None,
   )
 
 def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
@@ -7989,6 +8948,8 @@ def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
     "dh_pgc": None if data.dh_pgc is None else serialize_dhpgc_gripper_command_request(data.dh_pgc),
     "dh_cgi": None if data.dh_cgi is None else serialize_dhcgi_gripper_command_request(data.dh_cgi),
     "schunk_egx": None if data.schunk_egx is None else serialize_schunk_e_gx_gripper_command_request(data.schunk_egx),
+    "robotiq_2f": None if data.robotiq_2f is None else serialize_robotiq_2_f_gripper_command_request(data.robotiq_2f),
+    "robotiq_epick": None if data.robotiq_epick is None else serialize_robotiq_e_pick_gripper_command_request(data.robotiq_epick),
   }
 
 @dataclass
@@ -8189,6 +9150,7 @@ class RecorderConfig:
   offset: Union[OffsetConfig, None] = None
   sensors: Union[SensorConfigList, None] = None
   equipmentKeyAssignments: Union[EquipmentKeyAssignments, None] = None
+  tags: Union[StringArray, None] = None
 
   def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
     if value is None:
@@ -8253,6 +9215,15 @@ class RecorderConfig:
 
     return [True, ""]
 
+  def validate_tags(self, value: StringArray) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, str) for x in value)):
+      return [False, "tags must be of type StringArray for RecorderConfig, 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_isSecondary(self.isSecondary)
@@ -8276,6 +9247,9 @@ class RecorderConfig:
     is_valid, error_str = self.validate_equipmentKeyAssignments(self.equipmentKeyAssignments)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_tags(self.tags)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_recorder_config(data: object):
   return RecorderConfig(
@@ -8286,6 +9260,7 @@ def parse_recorder_config(data: object):
     offset=parse_offset_config(data["offset"]) if "offset" in data and data.get("offset") is not None else None,
     sensors=parse_sensor_config_list(data["sensors"]) if "sensors" in data and data.get("sensors") is not None else None,
     equipmentKeyAssignments=parse_equipment_key_assignments(data["equipmentKeyAssignments"]) if "equipmentKeyAssignments" in data and data.get("equipmentKeyAssignments") is not None else None,
+    tags=parse_string_array(data["tags"]) if "tags" in data and data.get("tags") is not None else None,
   )
 
 def serialize_recorder_config(data: RecorderConfig) -> object:
@@ -8297,6 +9272,7 @@ def serialize_recorder_config(data: RecorderConfig) -> object:
     "offset": None if data.offset is None else serialize_offset_config(data.offset),
     "sensors": None if data.sensors is None else serialize_sensor_config_list(data.sensors),
     "equipmentKeyAssignments": None if data.equipmentKeyAssignments is None else serialize_equipment_key_assignments(data.equipmentKeyAssignments),
+    "tags": None if data.tags is None else serialize_string_array(data.tags),
   }
 
 @dataclass
@@ -8304,6 +9280,7 @@ class TeleopConfig:
   """Config of the teleop"""
   isSecondary: Union[bool, None] = None
   bots: Union[BotTeleopDetailsList, None] = None
+  enableBoltHeadTracking: Union[bool, None] = None
 
   def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
     if value is None:
@@ -8323,6 +9300,15 @@ class TeleopConfig:
 
     return [True, ""]
 
+  def validate_enableBoltHeadTracking(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "enableBoltHeadTracking must be of type bool for TeleopConfig, 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_isSecondary(self.isSecondary)
@@ -8331,17 +9317,22 @@ class TeleopConfig:
     is_valid, error_str = self.validate_bots(self.bots)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_enableBoltHeadTracking(self.enableBoltHeadTracking)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_teleop_config(data: object):
   return TeleopConfig(
     isSecondary=parse_bool(data["isSecondary"]) if "isSecondary" in data and data.get("isSecondary") is not None else None,
     bots=parse_bot_teleop_details_list(data["bots"]) if "bots" in data and data.get("bots") is not None else None,
+    enableBoltHeadTracking=parse_bool(data["enableBoltHeadTracking"]) if "enableBoltHeadTracking" in data and data.get("enableBoltHeadTracking") is not None else None,
   )
 
 def serialize_teleop_config(data: TeleopConfig) -> object:
   return {
     "isSecondary": None if data.isSecondary is None else serialize_bool(data.isSecondary),
     "bots": None if data.bots is None else serialize_bot_teleop_details_list(data.bots),
+    "enableBoltHeadTracking": None if data.enableBoltHeadTracking is None else serialize_bool(data.enableBoltHeadTracking),
   }
 
 @dataclass
@@ -8838,6 +9829,12 @@ class TeleopState:
   config: Union[TeleopConfig, None] = None
   status: Union[TeleopStatus, None] = None
   botsInSync: Union[bool, None] = None
+  errors: Union[TeleopErrorArray, None] = None
+  gripperBounds: Union[GripperBounds, None] = None
+  robotFrame: Union[RobotFrame, None] = None
+  filterType: Union[str, None] = None
+  connectedClients: Union[TeleopClientList, None] = None
+  activeClientId: Union[str, None] = None
 
   def validate_config(self, value: TeleopConfig) -> Tuple[bool, str]:
     if value is None:
@@ -8866,6 +9863,60 @@ class TeleopState:
 
     return [True, ""]
 
+  def validate_errors(self, value: TeleopErrorArray) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, str) for x in value)):
+      return [False, "errors must be of type TeleopErrorArray for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_gripperBounds(self, value: GripperBounds) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, GripperBounds):
+      return [False, "gripperBounds must be of type GripperBounds for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_robotFrame(self, value: RobotFrame) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RobotFrame in ['world', 'tooltip']) or isinstance(value, RobotFrame)):
+      return [False, "robotFrame must be of type RobotFrame for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_filterType(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "filterType must be of type str for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_connectedClients(self, value: TeleopClientList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, TeleopClient) for x in value)):
+      return [False, "connectedClients must be of type TeleopClientList for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_activeClientId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "activeClientId must be of type str for TeleopState, 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_config(self.config)
@@ -8877,12 +9928,36 @@ class TeleopState:
     is_valid, error_str = self.validate_botsInSync(self.botsInSync)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_errors(self.errors)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_gripperBounds(self.gripperBounds)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_robotFrame(self.robotFrame)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_filterType(self.filterType)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_connectedClients(self.connectedClients)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_activeClientId(self.activeClientId)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_teleop_state(data: object):
   return TeleopState(
     config=parse_teleop_config(data["config"]) if "config" in data and data.get("config") is not None else None,
     status=parse_teleop_status(data["status"]) if "status" in data and data.get("status") is not None else None,
     botsInSync=parse_bool(data["botsInSync"]) if "botsInSync" in data and data.get("botsInSync") is not None else None,
+    errors=parse_teleop_error_array(data["errors"]) if "errors" in data and data.get("errors") is not None else None,
+    gripperBounds=parse_gripper_bounds(data["gripperBounds"]) if "gripperBounds" in data and data.get("gripperBounds") is not None else None,
+    robotFrame=parse_robot_frame(data["robotFrame"]) if "robotFrame" in data and data.get("robotFrame") is not None else None,
+    filterType=parse_str(data["filterType"]) if "filterType" in data and data.get("filterType") is not None else None,
+    connectedClients=parse_teleop_client_list(data["connectedClients"]) if "connectedClients" in data and data.get("connectedClients") is not None else None,
+    activeClientId=parse_str(data["activeClientId"]) if "activeClientId" in data and data.get("activeClientId") is not None else None,
   )
 
 def serialize_teleop_state(data: TeleopState) -> object:
@@ -8890,6 +9965,12 @@ def serialize_teleop_state(data: TeleopState) -> object:
     "config": None if data.config is None else serialize_teleop_config(data.config),
     "status": None if data.status is None else serialize_teleop_status(data.status),
     "botsInSync": None if data.botsInSync is None else serialize_bool(data.botsInSync),
+    "errors": None if data.errors is None else serialize_teleop_error_array(data.errors),
+    "gripperBounds": None if data.gripperBounds is None else serialize_gripper_bounds(data.gripperBounds),
+    "robotFrame": None if data.robotFrame is None else serialize_robot_frame(data.robotFrame),
+    "filterType": None if data.filterType is None else serialize_str(data.filterType),
+    "connectedClients": None if data.connectedClients is None else serialize_teleop_client_list(data.connectedClients),
+    "activeClientId": None if data.activeClientId is None else serialize_str(data.activeClientId),
   }
 
 @dataclass
@@ -9071,6 +10152,7 @@ class StopRecordingResponse:
   state: Union[RecorderState, None] = None
   startTimestamp: Union[str, None] = None
   endTimestamp: Union[str, None] = None
+  status: Union[RecorderStatus, None] = None
 
   def validate_state(self, value: RecorderState) -> Tuple[bool, str]:
     if value is None:
@@ -9099,6 +10181,15 @@ class StopRecordingResponse:
 
     return [True, ""]
 
+  def validate_status(self, value: RecorderStatus) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RecorderStatus in ['not_recording', 'recording', 'error', 'complete', 'initializing']) or isinstance(value, RecorderStatus)):
+      return [False, "status must be of type RecorderStatus for StopRecordingResponse, 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)
@@ -9110,12 +10201,16 @@ class StopRecordingResponse:
     is_valid, error_str = self.validate_endTimestamp(self.endTimestamp)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_status(self.status)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_stop_recording_response(data: object):
   return StopRecordingResponse(
     state=parse_recorder_state(data["state"]) if "state" in data and data.get("state") is not None else None,
     startTimestamp=parse_str(data["startTimestamp"]) if "startTimestamp" in data and data.get("startTimestamp") is not None else None,
     endTimestamp=parse_str(data["endTimestamp"]) if "endTimestamp" in data and data.get("endTimestamp") is not None else None,
+    status=parse_recorder_status(data["status"]) if "status" in data and data.get("status") is not None else None,
   )
 
 def serialize_stop_recording_response(data: StopRecordingResponse) -> object:
@@ -9123,6 +10218,7 @@ def serialize_stop_recording_response(data: StopRecordingResponse) -> object:
     "state": None if data.state is None else serialize_recorder_state(data.state),
     "startTimestamp": None if data.startTimestamp is None else serialize_str(data.startTimestamp),
     "endTimestamp": None if data.endTimestamp is None else serialize_str(data.endTimestamp),
+    "status": None if data.status is None else serialize_recorder_status(data.status),
   }
 
 @dataclass