standardbots 2.20250128.44__py3-none-any.whl → 2.20250417.2__py3-none-any.whl

standardbots/auto_generated/models.py

@@ -165,6 +165,8 @@ def serialize_arm_position_update_failure_event_kind(data: Union[ArmPositionUpda
   return ArmPositionUpdateFailureEventKind(data).value
 
 class ArmPositionUpdateKindEnum(Enum):
+  Creating = "creating"
+  """Enum Creating = `creating`"""
   Success = "success"
   """Enum Success = `success`"""
   Failure = "failure"
@@ -175,6 +177,20 @@ class ArmPositionUpdateKindEnum(Enum):
   """Enum Position = `position`"""
   Planning = "planning"
   """Enum Planning = `planning`"""
+  BeginMotion = "begin_motion"
+  """Enum BeginMotion = `begin_motion`"""
+  RequestingPlan = "requesting_plan"
+  """Enum RequestingPlan = `requesting_plan`"""
+  Waypoint = "waypoint"
+  """Enum Waypoint = `waypoint`"""
+  WaypointReached = "waypoint_reached"
+  """Enum WaypointReached = `waypoint_reached`"""
+  Pause = "pause"
+  """Enum Pause = `pause`"""
+  Resume = "resume"
+  """Enum Resume = `resume`"""
+  Complete = "complete"
+  """Enum Complete = `complete`"""
 
 def parse_arm_position_update_kind_enum(data: object) -> ArmPositionUpdateKindEnum:
   return ArmPositionUpdateKindEnum(data)
@@ -551,6 +567,51 @@ def serialize_camera_settings(data: CameraSettings) -> object:
     "autoWhiteBalance": None if data.autoWhiteBalance is None else serialize_bool(data.autoWhiteBalance),
   }
 
+@dataclass
+class CameraStatus:
+  """Current camera status."""
+  connected: Union[bool, None] = None
+  message: Union[str, None] = None
+
+  def validate_connected(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "connected must be of type bool for CameraStatus, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_message(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "message must be of type str for CameraStatus, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_connected(self.connected)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_message(self.message)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_status(data: object):
+  return CameraStatus(
+    connected=parse_bool(data["connected"]) if "connected" in data and data.get("connected") is not None else None,
+    message=parse_str(data["message"]) if "message" in data and data.get("message") is not None else None,
+  )
+
+def serialize_camera_status(data: CameraStatus) -> object:
+  return {
+    "connected": None if data.connected is None else serialize_bool(data.connected),
+    "message": None if data.message is None else serialize_str(data.message),
+  }
+
 @dataclass
 class CartesianPose:
   """Cartesian pose
@@ -1089,6 +1150,16 @@ class ErrorEnum(Enum):
   """Space specified was invalid or not found"""
   InvalidParameters = "invalid_parameters"
   """Parameters are invalid"""
+  RoutineDoesNotExist = "routine_does_not_exist"
+  """Routine does not exist"""
+  CannotPlayRoutine = "cannot_play_routine"
+  """Routine is not in the correct state to play"""
+  RoutineMustBePlaying = "routine_must_be_playing"
+  """Routine must be playing"""
+  CannotChangeRosState = "cannot_change_ros_state"
+  """Cannot change ROS state"""
+  IoSafeguardError = "io_safeguard_error"
+  """Cannot change IO state because of safeguard"""
 
 def parse_error_enum(data: object) -> ErrorEnum:
   return ErrorEnum(data)
@@ -1443,10 +1514,10 @@ def serialize_joint_state_disturbance(data: JointStateDisturbance) -> object:
   }
 
 class LinearGripDirectionEnum(Enum):
-  Inward = "inward"
-  """Move gripper inward to grip. Measure grip position based on interior of gripper fingers and exterior of object"""
-  Outward = "outward"
-  """Grip gripper outward to grip. Measure grip position based on exterior of gripper fingers and interior of object"""
+  Internal = "internal"
+  """Grip object on the inside of gripper fingers. Measure grip position based on interior of gripper fingers and exterior of object"""
+  External = "external"
+  """Grip object on the outside of gripper fingers. Measure grip position based on exterior of gripper fingers and interior of object"""
 
 def parse_linear_grip_direction_enum(data: object) -> LinearGripDirectionEnum:
   return LinearGripDirectionEnum(data)
@@ -1539,10 +1610,10 @@ def serialize_on_robot_3_fg_15_control_kind_enum(data: Union[OnRobot3FG15Control
   return OnRobot3FG15ControlKindEnum(data).value
 
 class OnRobotGripKindEnum(Enum):
-  Inward = "inward"
-  """Enum Inward = `inward`"""
-  Outward = "outward"
-  """Enum Outward = `outward`"""
+  Internal = "internal"
+  """Enum Internal = `internal`"""
+  External = "external"
+  """Enum External = `external`"""
 
 def parse_on_robot_grip_kind_enum(data: object) -> OnRobotGripKindEnum:
   return OnRobotGripKindEnum(data)
@@ -1815,6 +1886,66 @@ def serialize_pagination(data: Pagination) -> object:
     "offset": None if data.offset is None else serialize_i_64(data.offset),
   }
 
+@dataclass
+class PayloadStateRequest:
+  """Request to set the robot payload"""
+  mass: Union[float, None] = None
+
+  def validate_mass(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "mass must be of type float for PayloadStateRequest, 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(self.mass)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_payload_state_request(data: object):
+  return PayloadStateRequest(
+    mass=parse_f_64(data["mass"]) if "mass" in data and data.get("mass") is not None else None,
+  )
+
+def serialize_payload_state_request(data: PayloadStateRequest) -> object:
+  return {
+    "mass": None if data.mass is None else serialize_f_64(data.mass),
+  }
+
+@dataclass
+class PayloadStateResponse:
+  """Response containing the current payload state"""
+  mass: Union[float, None] = None
+
+  def validate_mass(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "mass must be of type float for PayloadStateResponse, 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(self.mass)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_payload_state_response(data: object):
+  return PayloadStateResponse(
+    mass=parse_f_64(data["mass"]) if "mass" in data and data.get("mass") is not None else None,
+  )
+
+def serialize_payload_state_response(data: PayloadStateResponse) -> object:
+  return {
+    "mass": None if data.mass is None else serialize_f_64(data.mass),
+  }
+
 @dataclass
 class Plane:
   """Plane in 3D space"""
@@ -2086,6 +2217,22 @@ def serialize_quaternion(data: Quaternion) -> object:
     "w": None if data.w is None else serialize_f_64(data.w),
   }
 
+class RecorderStatus(Enum):
+  NotRecording = "not_recording"
+  """Enum NotRecording = `not_recording`"""
+  Recording = "recording"
+  """Enum Recording = `recording`"""
+  Error = "error"
+  """Enum Error = `error`"""
+  Complete = "complete"
+  """Enum Complete = `complete`"""
+
+def parse_recorder_status(data: object) -> RecorderStatus:
+  return RecorderStatus(data)
+
+def serialize_recorder_status(data: Union[RecorderStatus, str]) -> object:
+  return RecorderStatus(data).value
+
 class RecoveryTypeEnum(Enum):
   Recoverable = "Recoverable"
   """Enum Recoverable = `Recoverable`"""
@@ -2351,6 +2498,66 @@ def serialize_runtime_variable(data: RuntimeVariable) -> object:
     "value": None if data.value is None else serialize_str(data.value),
   }
 
+@dataclass
+class SaveRecordingRequest:
+  """Request to save recording to marvin"""
+  recordingId: Union[str, None] = None
+  startTimestamp: Union[int, None] = None
+  endTimestamp: Union[int, None] = None
+
+  def validate_recordingId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "recordingId must be of type str for SaveRecordingRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_startTimestamp(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "startTimestamp must be of type int for SaveRecordingRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_endTimestamp(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "endTimestamp must be of type int for SaveRecordingRequest, 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_recordingId(self.recordingId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_startTimestamp(self.startTimestamp)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_endTimestamp(self.endTimestamp)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_save_recording_request(data: object):
+  return SaveRecordingRequest(
+    recordingId=parse_str(data["recordingId"]) if "recordingId" in data and data.get("recordingId") is not None else None,
+    startTimestamp=parse_u_64(data["startTimestamp"]) if "startTimestamp" in data and data.get("startTimestamp") is not None else None,
+    endTimestamp=parse_u_64(data["endTimestamp"]) if "endTimestamp" in data and data.get("endTimestamp") is not None else None,
+  )
+
+def serialize_save_recording_request(data: SaveRecordingRequest) -> object:
+  return {
+    "recordingId": None if data.recordingId is None else serialize_str(data.recordingId),
+    "startTimestamp": None if data.startTimestamp is None else serialize_u_64(data.startTimestamp),
+    "endTimestamp": None if data.endTimestamp is None else serialize_u_64(data.endTimestamp),
+  }
+
 class SchunkEGxControlKindEnum(Enum):
   Move = "move"
   """Move gripper to target grip diameter"""
@@ -2451,6 +2658,51 @@ def serialize_sensor(data: Sensor) -> object:
     "equipmentId": None if data.equipmentId is None else serialize_str(data.equipmentId),
   }
 
+@dataclass
+class SetRatioControlRequest:
+  """Request to set ratio control parameters"""
+  enabled: Union[bool, None] = None
+  value: Union[float, None] = None
+
+  def validate_enabled(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "enabled must be of type bool for SetRatioControlRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_value(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "value must be of type float for SetRatioControlRequest, 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_enabled(self.enabled)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_value(self.value)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_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,
+  )
+
+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),
+  }
+
 SkillsList = List[str]
 
 def parse_skills_list(data: object) -> SkillsList:
@@ -2489,6 +2741,36 @@ def serialize_speech_to_text_request(data: SpeechToTextRequest) -> object:
     "encoded_audio_data": None if data.encoded_audio_data is None else serialize_str(data.encoded_audio_data),
   }
 
+@dataclass
+class StartRecordingRequest:
+  """Request to start recording movement and camera data"""
+  startTime: Union[str, None] = None
+
+  def validate_startTime(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "startTime must be of type str for StartRecordingRequest, 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_startTime(self.startTime)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_start_recording_request(data: object):
+  return StartRecordingRequest(
+    startTime=parse_str(data["startTime"]) if "startTime" in data and data.get("startTime") is not None else None,
+  )
+
+def serialize_start_recording_request(data: StartRecordingRequest) -> object:
+  return {
+    "startTime": None if data.startTime is None else serialize_str(data.startTime),
+  }
+
 class StatusHealthEnum(Enum):
   Ok = "ok"
   """Enum Ok = `ok`"""
@@ -2548,6 +2830,152 @@ def serialize_status_version_data(data: StatusVersionData) -> object:
     "name": None if data.name is None else serialize_str(data.name),
   }
 
+@dataclass
+class StopRecordingRequest:
+  """Request to stop recording movement and camera data"""
+  delete: Union[bool, 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 __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)
+
+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 serialize_stop_recording_request(data: StopRecordingRequest) -> object:
+  return {
+    "delete": None if data.delete is None else serialize_bool(data.delete),
+  }
+
+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]
+
+class TeleopStatus(Enum):
+  WaitForTeleop = "wait_for_teleop"
+  """Enum WaitForTeleop = `wait_for_teleop`"""
+  Teleop = "teleop"
+  """Enum Teleop = `teleop`"""
+  Stopping = "stopping"
+  """Enum Stopping = `stopping`"""
+  Stopped = "stopped"
+  """Enum Stopped = `stopped`"""
+  Error = "error"
+  """Enum Error = `error`"""
+
+def parse_teleop_status(data: object) -> TeleopStatus:
+  return TeleopStatus(data)
+
+def serialize_teleop_status(data: Union[TeleopStatus, str]) -> object:
+  return TeleopStatus(data).value
+
+@dataclass
+class ToggleRecorderBotRequest:
+  """Request to enable or disable a secondary bot"""
+  botId: Union[str, None] = None
+  enabled: Union[bool, None] = None
+
+  def validate_botId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "botId must be of type str for ToggleRecorderBotRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_enabled(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "enabled must be of type bool for ToggleRecorderBotRequest, 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)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_enabled(self.enabled)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_toggle_recorder_bot_request(data: object):
+  return ToggleRecorderBotRequest(
+    botId=parse_str(data["botId"]) if "botId" in data and data.get("botId") is not None else None,
+    enabled=parse_bool(data["enabled"]) if "enabled" in data and data.get("enabled") is not None else None,
+  )
+
+def serialize_toggle_recorder_bot_request(data: ToggleRecorderBotRequest) -> object:
+  return {
+    "botId": None if data.botId is None else serialize_str(data.botId),
+    "enabled": None if data.enabled is None else serialize_bool(data.enabled),
+  }
+
+@dataclass
+class ToggleTeleopBotRequest:
+  """Request to enable or disable a secondary bot"""
+  botId: Union[str, None] = None
+  enabled: Union[bool, None] = None
+
+  def validate_botId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "botId must be of type str for ToggleTeleopBotRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_enabled(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "enabled must be of type bool for ToggleTeleopBotRequest, 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)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_enabled(self.enabled)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_toggle_teleop_bot_request(data: object):
+  return ToggleTeleopBotRequest(
+    botId=parse_str(data["botId"]) if "botId" in data and data.get("botId") is not None else None,
+    enabled=parse_bool(data["enabled"]) if "enabled" in data and data.get("enabled") is not None else None,
+  )
+
+def serialize_toggle_teleop_bot_request(data: ToggleTeleopBotRequest) -> object:
+  return {
+    "botId": None if data.botId is None else serialize_str(data.botId),
+    "enabled": None if data.enabled is None else serialize_bool(data.enabled),
+  }
+
 @dataclass
 class TriggerFaultRequest:
   """Request to trigger an user fault for routine.
@@ -2694,46 +3122,16 @@ def serialize_brakes_state(data: BrakesState) -> object:
   }
 
 @dataclass
-class CameraIntrinsicsResponse:
-  """Response with intrinsic parameters of the camera."""
-  intrinsics: Union[CameraIntrinsics, None] = None
+class CameraFrameRequest:
+  """Request for a single camera frame. In JPEG format."""
+  camera_settings: Union[CameraSettings, None] = None
 
-  def validate_intrinsics(self, value: CameraIntrinsics) -> Tuple[bool, str]:
+  def validate_camera_settings(self, value: CameraSettings) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, CameraIntrinsics):
-      return [False, "intrinsics must be of type CameraIntrinsics for CameraIntrinsicsResponse, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_intrinsics(self.intrinsics)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_camera_intrinsics_response(data: object):
-  return CameraIntrinsicsResponse(
-    intrinsics=parse_camera_intrinsics(data["intrinsics"]) if "intrinsics" in data and data.get("intrinsics") is not None else None,
-  )
-
-def serialize_camera_intrinsics_response(data: CameraIntrinsicsResponse) -> object:
-  return {
-    "intrinsics": None if data.intrinsics is None else serialize_camera_intrinsics(data.intrinsics),
-  }
-
-@dataclass
-class CameraFrameRequest:
-  """Request for a single camera frame. In JPEG format."""
-  camera_settings: Union[CameraSettings, None] = None
-
-  def validate_camera_settings(self, value: CameraSettings) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, CameraSettings):
-      return [False, "camera_settings must be of type CameraSettings for CameraFrameRequest, got " + type(value).__name__]
+    if not isinstance(value, CameraSettings):
+      return [False, "camera_settings must be of type CameraSettings for CameraFrameRequest, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -3047,7 +3445,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']) or isinstance(value, ErrorEnum)):
+    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'robot_not_idle', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'recovery_error', 'not_found', 'invalid_space_specified', 'invalid_parameters', 'routine_does_not_exist', 'cannot_play_routine', 'routine_must_be_playing', 'cannot_change_ros_state', 'io_safeguard_error']) or isinstance(value, ErrorEnum)):
       return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
@@ -3863,7 +4261,7 @@ class OnRobot2FG14GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -4163,7 +4561,7 @@ class OnRobot2FG7GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -4492,7 +4890,7 @@ class OnRobot3FG15GripperConfiguration:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
+    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['internal', 'external']) or isinstance(value, OnRobotGripKindEnum)):
       return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -4729,6 +5127,96 @@ def serialize_orientation(data: Orientation) -> object:
     "quaternion": None if data.quaternion is None else serialize_quaternion(data.quaternion),
   }
 
+@dataclass
+class RecorderBotDetails:
+  """Details of the bot"""
+  botId: Union[str, None] = None
+  alias: Union[str, None] = None
+  isSecondary: Union[bool, None] = None
+  isEnabled: Union[bool, None] = None
+  status: Union[RecorderStatus, None] = None
+
+  def validate_botId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "botId must be of type str for RecorderBotDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_alias(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "alias must be of type str for RecorderBotDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "isSecondary must be of type bool for RecorderBotDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_isEnabled(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "isEnabled must be of type bool for RecorderBotDetails, got " + type(value).__name__]
+
+    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']) or isinstance(value, RecorderStatus)):
+      return [False, "status must be of type RecorderStatus for RecorderBotDetails, 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)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_alias(self.alias)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_isSecondary(self.isSecondary)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_isEnabled(self.isEnabled)
+    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_recorder_bot_details(data: object):
+  return RecorderBotDetails(
+    botId=parse_str(data["botId"]) if "botId" in data and data.get("botId") is not None else None,
+    alias=parse_str(data["alias"]) if "alias" in data and data.get("alias") is not None else None,
+    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_recorder_status(data["status"]) if "status" in data and data.get("status") is not None else None,
+  )
+
+def serialize_recorder_bot_details(data: RecorderBotDetails) -> object:
+  return {
+    "botId": None if data.botId is None else serialize_str(data.botId),
+    "alias": None if data.alias is None else serialize_str(data.alias),
+    "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_recorder_status(data.status),
+  }
+
 @dataclass
 class FailureStateDetails:
   """Failure state details."""
@@ -4864,6 +5352,36 @@ def serialize_robot_control_mode(data: RobotControlMode) -> object:
     "kind": None if data.kind is None else serialize_robot_control_mode_enum(data.kind),
   }
 
+@dataclass
+class PlayRoutineResponse:
+  """Status response informs user of of robot state"""
+  status: Union[RobotStatusEnum, None] = None
+
+  def validate_status(self, value: RobotStatusEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RobotStatusEnum in ['Idle', 'RunningAdHocCommand', 'RoutineRunning', 'Antigravity', 'AntigravitySlow', 'Failure', 'Recovering']) or isinstance(value, RobotStatusEnum)):
+      return [False, "status must be of type RobotStatusEnum for PlayRoutineResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_status(self.status)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_play_routine_response(data: object):
+  return PlayRoutineResponse(
+    status=parse_robot_status_enum(data["status"]) if "status" in data and data.get("status") is not None else None,
+  )
+
+def serialize_play_routine_response(data: PlayRoutineResponse) -> object:
+  return {
+    "status": None if data.status is None else serialize_robot_status_enum(data.status),
+  }
+
 @dataclass
 class ROSControlStateResponse:
   """Response to a query for the current state of ROS control."""
@@ -5097,6 +5615,171 @@ def serialize_status_health_response(data: StatusHealthResponse) -> object:
     "build": None if data.build is None else serialize_status_version_data(data.build),
   }
 
+@dataclass
+class SaveRecordingResponse:
+  """Response to save recording to marvin app"""
+  uploadId: Union[str, None] = None
+  errors: Union[StringArray, None] = None
+
+  def validate_uploadId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "uploadId must be of type str for SaveRecordingResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_errors(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, "errors must be of type StringArray for SaveRecordingResponse, 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_uploadId(self.uploadId)
+    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)
+
+def parse_save_recording_response(data: object):
+  return SaveRecordingResponse(
+    uploadId=parse_str(data["uploadId"]) if "uploadId" in data and data.get("uploadId") is not None else None,
+    errors=parse_string_array(data["errors"]) if "errors" in data and data.get("errors") is not None else None,
+  )
+
+def serialize_save_recording_response(data: SaveRecordingResponse) -> object:
+  return {
+    "uploadId": None if data.uploadId is None else serialize_str(data.uploadId),
+    "errors": None if data.errors is None else serialize_string_array(data.errors),
+  }
+
+@dataclass
+class BotTeleopDetails:
+  """Details of the bot"""
+  botId: Union[str, None] = None
+  alias: Union[str, None] = None
+  url: Union[str, None] = None
+  token: Union[str, None] = None
+  isSecondary: Union[bool, None] = None
+  isEnabled: Union[bool, None] = None
+  status: Union[TeleopStatus, None] = None
+
+  def validate_botId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "botId must be of type str for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_alias(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "alias must be of type str for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_url(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "url must be of type str for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_token(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "token must be of type str for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "isSecondary must be of type bool for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_isEnabled(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "isEnabled must be of type bool for BotTeleopDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_status(self, value: TeleopStatus) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and TeleopStatus in ['wait_for_teleop', 'teleop', 'stopping', 'stopped', 'error']) or isinstance(value, TeleopStatus)):
+      return [False, "status must be of type TeleopStatus 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)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_alias(self.alias)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_url(self.url)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_token(self.token)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_isSecondary(self.isSecondary)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_isEnabled(self.isEnabled)
+    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_bot_teleop_details(data: object):
+  return BotTeleopDetails(
+    botId=parse_str(data["botId"]) if "botId" in data and data.get("botId") is not None else None,
+    alias=parse_str(data["alias"]) if "alias" in data and data.get("alias") is not None else None,
+    url=parse_str(data["url"]) if "url" in data and data.get("url") is not None else None,
+    token=parse_str(data["token"]) if "token" in data and data.get("token") is not None else None,
+    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,
+  )
+
+def serialize_bot_teleop_details(data: BotTeleopDetails) -> object:
+  return {
+    "botId": None if data.botId is None else serialize_str(data.botId),
+    "alias": None if data.alias is None else serialize_str(data.alias),
+    "url": None if data.url is None else serialize_str(data.url),
+    "token": None if data.token is None else serialize_str(data.token),
+    "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),
+  }
+
 @dataclass
 class ArmPositionUpdateRequestResponseEventStreamDetails:
   """Specify how the response should be sent
@@ -5374,7 +6057,7 @@ class OnRobot2FG14GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot2FG14GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot2FG14GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5450,7 +6133,7 @@ class OnRobot2FG7GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot2FG7GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot2FG7GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5526,7 +6209,7 @@ class OnRobot3FG15GripperCommandRequest:
     if value is None:
       return [False, "grip_direction is required for OnRobot3FG15GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['internal', 'external']) or isinstance(value, LinearGripDirectionEnum)):
       return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot3FG15GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -5635,6 +6318,51 @@ def serialize_schunk_e_gx_gripper_command_request(data: SchunkEGxGripperCommandR
     "control_kind": serialize_schunk_e_gx_control_kind_enum(data.control_kind),
   }
 
+@dataclass
+class OffsetConfig:
+  """Config of the offset"""
+  position: Union[Position, None] = None
+  orientation: Union[Quaternion, None] = None
+
+  def validate_position(self, value: Position) -> 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__]
+
+    return [True, ""]
+
+  def validate_orientation(self, value: Quaternion) -> 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__]
+
+    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)
+    is_valid, error_str = self.validate_orientation(self.orientation)
+    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 serialize_offset_config(data: OffsetConfig) -> 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),
+  }
+
 @dataclass
 class GripperConfiguration:
   """Configuration of gripper, also known as End Effector"""
@@ -5913,6 +6641,14 @@ def serialize_position_and_orientation(data: PositionAndOrientation) -> object:
     "orientation": serialize_orientation(data.orientation),
   }
 
+RecorderBotDetailsList = List[RecorderBotDetails]
+
+def parse_recorder_bot_details_list(data: object) -> RecorderBotDetailsList:
+  return [parse_recorder_bot_details(item) for item in data]
+
+def serialize_recorder_bot_details_list(data: RecorderBotDetailsList) -> List[object]:
+  return [serialize_recorder_bot_details(item) for item in data]
+
 @dataclass
 class FailureStateResponse:
   """Failure state response informs user of how and whether the robot may be recovered."""
@@ -6003,6 +6739,14 @@ def serialize_sensors_configuration(data: SensorsConfiguration) -> object:
     "sensors": None if data.sensors is None else serialize_sensors_list(data.sensors),
   }
 
+BotTeleopDetailsList = List[BotTeleopDetails]
+
+def parse_bot_teleop_details_list(data: object) -> BotTeleopDetailsList:
+  return [parse_bot_teleop_details(item) for item in data]
+
+def serialize_bot_teleop_details_list(data: BotTeleopDetailsList) -> List[object]:
+  return [serialize_bot_teleop_details(item) for item in data]
+
 @dataclass
 class ArmPositionUpdateRequestResponseFormat:
   """Specify how the response should be sent
@@ -6058,7 +6802,7 @@ def serialize_routines_list(data: RoutinesList) -> List[object]:
   return [serialize_routine(item) for item in data]
 
 @dataclass
-class ActiveCalibrationResponse:
+class ActiveCalibrationContainer:
   """The response to an active calibration request"""
   calibrationData: Union[CalibrationData, None] = None
 
@@ -6067,7 +6811,7 @@ class ActiveCalibrationResponse:
       return [True, ""]
 
     if not isinstance(value, CalibrationData):
-      return [False, "calibrationData must be of type CalibrationData for ActiveCalibrationResponse, got " + type(value).__name__]
+      return [False, "calibrationData must be of type CalibrationData for ActiveCalibrationContainer, got " + type(value).__name__]
 
     return [True, ""]
 
@@ -6077,12 +6821,12 @@ class ActiveCalibrationResponse:
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_active_calibration_response(data: object):
-  return ActiveCalibrationResponse(
+def parse_active_calibration_container(data: object):
+  return ActiveCalibrationContainer(
     calibrationData=parse_calibration_data(data["calibrationData"]) if "calibrationData" in data and data.get("calibrationData") is not None else None,
   )
 
-def serialize_active_calibration_response(data: ActiveCalibrationResponse) -> object:
+def serialize_active_calibration_container(data: ActiveCalibrationContainer) -> object:
   return {
     "calibrationData": None if data.calibrationData is None else serialize_calibration_data(data.calibrationData),
   }
@@ -6382,9 +7126,144 @@ def serialize_position_and_orientation_list(data: PositionAndOrientationList) ->
   return [serialize_position_and_orientation(item) for item in data]
 
 @dataclass
-class RoutinesPaginatedResponse:
-  """Paginated response containing routine data"""
-  items: Union[RoutinesList, None] = None
+class RecorderConfig:
+  """Config of the recorder"""
+  isSecondary: Union[bool, None] = None
+  userId: Union[str, None] = None
+  taskId: Union[str, None] = None
+  bots: Union[RecorderBotDetailsList, None] = None
+  offset: Union[OffsetConfig, None] = None
+
+  def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "isSecondary must be of type bool for RecorderConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_userId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "userId must be of type str for RecorderConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_taskId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "taskId must be of type str for RecorderConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_bots(self, value: RecorderBotDetailsList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, RecorderBotDetails) for x in value)):
+      return [False, "bots must be of type RecorderBotDetailsList for RecorderConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_offset(self, value: OffsetConfig) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, OffsetConfig):
+      return [False, "offset must be of type OffsetConfig 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)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_userId(self.userId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_taskId(self.taskId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_bots(self.bots)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_offset(self.offset)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_recorder_config(data: object):
+  return RecorderConfig(
+    isSecondary=parse_bool(data["isSecondary"]) if "isSecondary" in data and data.get("isSecondary") is not None else None,
+    userId=parse_str(data["userId"]) if "userId" in data and data.get("userId") is not None else None,
+    taskId=parse_str(data["taskId"]) if "taskId" in data and data.get("taskId") is not None else None,
+    bots=parse_recorder_bot_details_list(data["bots"]) if "bots" in data and data.get("bots") is not None else None,
+    offset=parse_offset_config(data["offset"]) if "offset" in data and data.get("offset") is not None else None,
+  )
+
+def serialize_recorder_config(data: RecorderConfig) -> object:
+  return {
+    "isSecondary": None if data.isSecondary is None else serialize_bool(data.isSecondary),
+    "userId": None if data.userId is None else serialize_str(data.userId),
+    "taskId": None if data.taskId is None else serialize_str(data.taskId),
+    "bots": None if data.bots is None else serialize_recorder_bot_details_list(data.bots),
+    "offset": None if data.offset is None else serialize_offset_config(data.offset),
+  }
+
+@dataclass
+class TeleopConfig:
+  """Config of the teleop"""
+  isSecondary: Union[bool, None] = None
+  bots: Union[BotTeleopDetailsList, None] = None
+
+  def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "isSecondary must be of type bool for TeleopConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_bots(self, value: BotTeleopDetailsList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, BotTeleopDetails) for x in value)):
+      return [False, "bots must be of type BotTeleopDetailsList 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)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_bots(self.bots)
+    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,
+  )
+
+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),
+  }
+
+@dataclass
+class RoutinesPaginatedResponse:
+  """Paginated response containing routine data"""
+  items: Union[RoutinesList, None] = None
   pagination: Union[Pagination, None] = None
 
   def validate_items(self, value: RoutinesList) -> Tuple[bool, str]:
@@ -6446,7 +7325,7 @@ class ArmPositionUpdateEvent:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and ArmPositionUpdateKindEnum in ['success', 'failure', 'canceled', 'position', 'planning']) or isinstance(value, ArmPositionUpdateKindEnum)):
+    if not ((isinstance(value, str) and ArmPositionUpdateKindEnum in ['creating', 'success', 'failure', 'canceled', 'position', 'planning', 'begin_motion', 'requesting_plan', 'waypoint', 'waypoint_reached', 'pause', 'resume', 'complete']) or isinstance(value, ArmPositionUpdateKindEnum)):
       return [False, "kind must be of type ArmPositionUpdateKindEnum for ArmPositionUpdateEvent, got " + type(value).__name__]
 
     return [True, ""]
@@ -6509,6 +7388,156 @@ def serialize_arm_position_update_event(data: ArmPositionUpdateEvent) -> object:
     "position": None if data.position is None else serialize_combined_arm_position(data.position),
   }
 
+@dataclass
+class ArmPositionUpdateControlledRequest:
+  """Move the robot in a controlled manner (i.e. with a heartbeat)"""
+  heartbeat_interval: Union[int, None] = None
+  expires_after_ms: Union[int, None] = None
+  kind: Union[ArmPositionUpdateRequestKindEnum, None] = None
+  tooltip_positions: Union[PositionAndOrientationList, None] = None
+  tooltip_position: Union[PositionAndOrientation, None] = None
+  joint_rotations: Union[ArmJointRotationsList, None] = None
+  joint_rotation: Union[ArmJointRotations, None] = None
+  movement_kind: Union[MovementKindEnum, None] = None
+  speed_profile: Union[SpeedProfile, None] = None
+
+  def validate_heartbeat_interval(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "heartbeat_interval must be of type int for ArmPositionUpdateControlledRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_expires_after_ms(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "expires_after_ms must be of type int for ArmPositionUpdateControlledRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_kind(self, value: ArmPositionUpdateRequestKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "kind is required for ArmPositionUpdateControlledRequest"]
+
+    if not ((isinstance(value, str) and ArmPositionUpdateRequestKindEnum in ['tooltip_positions', 'tooltip_position', 'joint_rotations', 'joint_rotation']) or isinstance(value, ArmPositionUpdateRequestKindEnum)):
+      return [False, "kind must be of type ArmPositionUpdateRequestKindEnum for ArmPositionUpdateControlledRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_tooltip_positions(self, value: PositionAndOrientationList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, PositionAndOrientation) for x in value)):
+      return [False, "tooltip_positions must be of type PositionAndOrientationList for ArmPositionUpdateControlledRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_tooltip_position(self, value: PositionAndOrientation) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, PositionAndOrientation):
+      return [False, "tooltip_position must be of type PositionAndOrientation for ArmPositionUpdateControlledRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint_rotations(self, value: ArmJointRotationsList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, ArmJointRotations) for x in value)):
+      return [False, "joint_rotations must be of type ArmJointRotationsList for ArmPositionUpdateControlledRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_joint_rotation(self, value: ArmJointRotations) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, ArmJointRotations):
+      return [False, "joint_rotation must be of type ArmJointRotations for ArmPositionUpdateControlledRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_movement_kind(self, value: MovementKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and MovementKindEnum in ['joint', 'line']) or isinstance(value, MovementKindEnum)):
+      return [False, "movement_kind must be of type MovementKindEnum for ArmPositionUpdateControlledRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_speed_profile(self, value: SpeedProfile) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, SpeedProfile):
+      return [False, "speed_profile must be of type SpeedProfile for ArmPositionUpdateControlledRequest, 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_heartbeat_interval(self.heartbeat_interval)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_expires_after_ms(self.expires_after_ms)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_kind(self.kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_tooltip_positions(self.tooltip_positions)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_tooltip_position(self.tooltip_position)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint_rotations(self.joint_rotations)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_joint_rotation(self.joint_rotation)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_movement_kind(self.movement_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_speed_profile(self.speed_profile)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_arm_position_update_controlled_request(data: object):
+  return ArmPositionUpdateControlledRequest(
+    heartbeat_interval=parse_i_64(data["heartbeat_interval"]) if "heartbeat_interval" in data and data.get("heartbeat_interval") is not None else None,
+    expires_after_ms=parse_i_64(data["expires_after_ms"]) if "expires_after_ms" in data and data.get("expires_after_ms") is not None else None,
+    kind=parse_arm_position_update_request_kind_enum(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    tooltip_positions=parse_position_and_orientation_list(data["tooltip_positions"]) if "tooltip_positions" in data and data.get("tooltip_positions") is not None else None,
+    tooltip_position=parse_position_and_orientation(data["tooltip_position"]) if "tooltip_position" in data and data.get("tooltip_position") is not None else None,
+    joint_rotations=parse_arm_joint_rotations_list(data["joint_rotations"]) if "joint_rotations" in data and data.get("joint_rotations") is not None else None,
+    joint_rotation=parse_arm_joint_rotations(data["joint_rotation"]) if "joint_rotation" in data and data.get("joint_rotation") is not None else None,
+    movement_kind=parse_movement_kind_enum(data["movement_kind"]) if "movement_kind" in data and data.get("movement_kind") is not None else None,
+    speed_profile=parse_speed_profile(data["speed_profile"]) if "speed_profile" in data and data.get("speed_profile") is not None else None,
+  )
+
+def serialize_arm_position_update_controlled_request(data: ArmPositionUpdateControlledRequest) -> object:
+  return {
+    "heartbeat_interval": None if data.heartbeat_interval is None else serialize_i_64(data.heartbeat_interval),
+    "expires_after_ms": None if data.expires_after_ms is None else serialize_i_64(data.expires_after_ms),
+    "kind": serialize_arm_position_update_request_kind_enum(data.kind),
+    "tooltip_positions": None if data.tooltip_positions is None else serialize_position_and_orientation_list(data.tooltip_positions),
+    "tooltip_position": None if data.tooltip_position is None else serialize_position_and_orientation(data.tooltip_position),
+    "joint_rotations": None if data.joint_rotations is None else serialize_arm_joint_rotations_list(data.joint_rotations),
+    "joint_rotation": None if data.joint_rotation is None else serialize_arm_joint_rotations(data.joint_rotation),
+    "movement_kind": None if data.movement_kind is None else serialize_movement_kind_enum(data.movement_kind),
+    "speed_profile": None if data.speed_profile is None else serialize_speed_profile(data.speed_profile),
+  }
+
 @dataclass
 class ArmPositionUpdateRequest:
   """Move the robot"""
@@ -6519,7 +7548,6 @@ class ArmPositionUpdateRequest:
   joint_rotation: Union[ArmJointRotations, None] = None
   movement_kind: Union[MovementKindEnum, None] = None
   speed_profile: Union[SpeedProfile, None] = None
-  response: Union[ArmPositionUpdateRequestResponseFormat, None] = None
 
   def validate_kind(self, value: ArmPositionUpdateRequestKindEnum) -> Tuple[bool, str]:
     if value is None:
@@ -6584,15 +7612,6 @@ class ArmPositionUpdateRequest:
 
     return [True, ""]
 
-  def validate_response(self, value: ArmPositionUpdateRequestResponseFormat) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, ArmPositionUpdateRequestResponseFormat):
-      return [False, "response must be of type ArmPositionUpdateRequestResponseFormat for ArmPositionUpdateRequest, 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)
@@ -6616,9 +7635,6 @@ class ArmPositionUpdateRequest:
     is_valid, error_str = self.validate_speed_profile(self.speed_profile)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_response(self.response)
-    if not is_valid:
-      raise TypeError(error_str)
 
 def parse_arm_position_update_request(data: object):
   return ArmPositionUpdateRequest(
@@ -6629,7 +7645,6 @@ def parse_arm_position_update_request(data: object):
     joint_rotation=parse_arm_joint_rotations(data["joint_rotation"]) if "joint_rotation" in data and data.get("joint_rotation") is not None else None,
     movement_kind=parse_movement_kind_enum(data["movement_kind"]) if "movement_kind" in data and data.get("movement_kind") is not None else None,
     speed_profile=parse_speed_profile(data["speed_profile"]) if "speed_profile" in data and data.get("speed_profile") is not None else None,
-    response=parse_arm_position_update_request_response_format(data["response"]) if "response" in data and data.get("response") is not None else None,
   )
 
 def serialize_arm_position_update_request(data: ArmPositionUpdateRequest) -> object:
@@ -6641,7 +7656,141 @@ def serialize_arm_position_update_request(data: ArmPositionUpdateRequest) -> obj
     "joint_rotation": None if data.joint_rotation is None else serialize_arm_joint_rotations(data.joint_rotation),
     "movement_kind": None if data.movement_kind is None else serialize_movement_kind_enum(data.movement_kind),
     "speed_profile": None if data.speed_profile is None else serialize_speed_profile(data.speed_profile),
-    "response": None if data.response is None else serialize_arm_position_update_request_response_format(data.response),
+  }
+
+@dataclass
+class RecorderState:
+  """State of the recorder"""
+  config: Union[RecorderConfig, None] = None
+  startTime: Union[str, None] = None
+  recordingTime: Union[int, None] = None
+  status: Union[RecorderStatus, None] = None
+
+  def validate_config(self, value: RecorderConfig) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, RecorderConfig):
+      return [False, "config must be of type RecorderConfig for RecorderState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_startTime(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "startTime must be of type str for RecorderState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_recordingTime(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "recordingTime must be of type int for RecorderState, got " + type(value).__name__]
+
+    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']) or isinstance(value, RecorderStatus)):
+      return [False, "status must be of type RecorderStatus for RecorderState, 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)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_startTime(self.startTime)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_recordingTime(self.recordingTime)
+    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_recorder_state(data: object):
+  return RecorderState(
+    config=parse_recorder_config(data["config"]) if "config" in data and data.get("config") is not None else None,
+    startTime=parse_str(data["startTime"]) if "startTime" in data and data.get("startTime") is not None else None,
+    recordingTime=parse_u_64(data["recordingTime"]) if "recordingTime" in data and data.get("recordingTime") 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_recorder_state(data: RecorderState) -> object:
+  return {
+    "config": None if data.config is None else serialize_recorder_config(data.config),
+    "startTime": None if data.startTime is None else serialize_str(data.startTime),
+    "recordingTime": None if data.recordingTime is None else serialize_u_64(data.recordingTime),
+    "status": None if data.status is None else serialize_recorder_status(data.status),
+  }
+
+@dataclass
+class TeleopState:
+  """State of the teleop"""
+  config: Union[TeleopConfig, None] = None
+  status: Union[TeleopStatus, None] = None
+  botsInSync: Union[bool, None] = None
+
+  def validate_config(self, value: TeleopConfig) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, TeleopConfig):
+      return [False, "config must be of type TeleopConfig for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_status(self, value: TeleopStatus) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and TeleopStatus in ['wait_for_teleop', 'teleop', 'stopping', 'stopped', 'error']) or isinstance(value, TeleopStatus)):
+      return [False, "status must be of type TeleopStatus for TeleopState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_botsInSync(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "botsInSync must be of type bool 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)
+    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)
+    is_valid, error_str = self.validate_botsInSync(self.botsInSync)
+    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,
+  )
+
+def serialize_teleop_state(data: TeleopState) -> object:
+  return {
+    "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),
   }
 
 @dataclass
@@ -6682,3 +7831,348 @@ def parse_arm_position_update_event_stream(data: object) -> ArmPositionUpdateEve
 def serialize_arm_position_update_event_stream(data: ArmPositionUpdateEventStream) -> List[object]:
   return [serialize_arm_position_update_event(item) for item in data]
 
+@dataclass
+class SetArmPositionControlledResponse:
+  """Response from the controlled robot movement API"""
+  id: Union[str, None] = None
+  is_active: Union[bool, None] = None
+  expires_at: Union[int, None] = None
+  heartbeat_interval: Union[int, None] = None
+  event: Union[ArmPositionUpdateEvent, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "id is required for SetArmPositionControlledResponse"]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for SetArmPositionControlledResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_is_active(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "is_active is required for SetArmPositionControlledResponse"]
+
+    if not isinstance(value, bool):
+      return [False, "is_active must be of type bool for SetArmPositionControlledResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_expires_at(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "expires_at must be of type int for SetArmPositionControlledResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_heartbeat_interval(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "heartbeat_interval is required for SetArmPositionControlledResponse"]
+
+    if not isinstance(value, int):
+      return [False, "heartbeat_interval must be of type int for SetArmPositionControlledResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_event(self, value: ArmPositionUpdateEvent) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "event is required for SetArmPositionControlledResponse"]
+
+    if not isinstance(value, ArmPositionUpdateEvent):
+      return [False, "event must be of type ArmPositionUpdateEvent for SetArmPositionControlledResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_id(self.id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_is_active(self.is_active)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_expires_at(self.expires_at)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_heartbeat_interval(self.heartbeat_interval)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_event(self.event)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_set_arm_position_controlled_response(data: object):
+  return SetArmPositionControlledResponse(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    is_active=parse_bool(data["is_active"]) if "is_active" in data and data.get("is_active") is not None else None,
+    expires_at=parse_i_64(data["expires_at"]) if "expires_at" in data and data.get("expires_at") is not None else None,
+    heartbeat_interval=parse_i_64(data["heartbeat_interval"]) if "heartbeat_interval" in data and data.get("heartbeat_interval") is not None else None,
+    event=parse_arm_position_update_event(data["event"]) if "event" in data and data.get("event") is not None else None,
+  )
+
+def serialize_set_arm_position_controlled_response(data: SetArmPositionControlledResponse) -> object:
+  return {
+    "id": serialize_str(data.id),
+    "is_active": serialize_bool(data.is_active),
+    "expires_at": None if data.expires_at is None else serialize_i_64(data.expires_at),
+    "heartbeat_interval": serialize_i_64(data.heartbeat_interval),
+    "event": serialize_arm_position_update_event(data.event),
+  }
+
+@dataclass
+class StartRecordingResponse:
+  """Response to start recording movement and camera data"""
+  success: Union[bool, None] = None
+  state: Union[RecorderState, None] = None
+
+  def validate_success(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "success must be of type bool for StartRecordingResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_state(self, value: RecorderState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, RecorderState):
+      return [False, "state must be of type RecorderState for StartRecordingResponse, 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_success(self.success)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_start_recording_response(data: object):
+  return StartRecordingResponse(
+    success=parse_bool(data["success"]) if "success" in data and data.get("success") is not None else None,
+    state=parse_recorder_state(data["state"]) if "state" in data and data.get("state") is not None else None,
+  )
+
+def serialize_start_recording_response(data: StartRecordingResponse) -> object:
+  return {
+    "success": None if data.success is None else serialize_bool(data.success),
+    "state": None if data.state is None else serialize_recorder_state(data.state),
+  }
+
+@dataclass
+class StopRecordingResponse:
+  """Response to stop recording movement and camera data"""
+  state: Union[RecorderState, None] = None
+  startTimestamp: Union[str, None] = None
+  endTimestamp: Union[str, None] = None
+
+  def validate_state(self, value: RecorderState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, RecorderState):
+      return [False, "state must be of type RecorderState for StopRecordingResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_startTimestamp(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "startTimestamp must be of type str for StopRecordingResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_endTimestamp(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "endTimestamp must be of type str 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)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_startTimestamp(self.startTimestamp)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_endTimestamp(self.endTimestamp)
+    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,
+  )
+
+def serialize_stop_recording_response(data: StopRecordingResponse) -> object:
+  return {
+    "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),
+  }
+
+@dataclass
+class UpdateRecordingResponse:
+  """Response to update recording configuration"""
+  success: Union[bool, None] = None
+  state: Union[RecorderState, None] = None
+  errors: Union[StringArray, None] = None
+
+  def validate_success(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "success must be of type bool for UpdateRecordingResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_state(self, value: RecorderState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, RecorderState):
+      return [False, "state must be of type RecorderState for UpdateRecordingResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_errors(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, "errors must be of type StringArray for UpdateRecordingResponse, 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_success(self.success)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_state(self.state)
+    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)
+
+def parse_update_recording_response(data: object):
+  return UpdateRecordingResponse(
+    success=parse_bool(data["success"]) if "success" in data and data.get("success") is not None else None,
+    state=parse_recorder_state(data["state"]) if "state" in data and data.get("state") is not None else None,
+    errors=parse_string_array(data["errors"]) if "errors" in data and data.get("errors") is not None else None,
+  )
+
+def serialize_update_recording_response(data: UpdateRecordingResponse) -> object:
+  return {
+    "success": None if data.success is None else serialize_bool(data.success),
+    "state": None if data.state is None else serialize_recorder_state(data.state),
+    "errors": None if data.errors is None else serialize_string_array(data.errors),
+  }
+
+@dataclass
+class StartTeleopResponse:
+  """Response to start teleoperation"""
+  success: Union[bool, None] = None
+  state: Union[TeleopState, None] = None
+
+  def validate_success(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "success must be of type bool for StartTeleopResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_state(self, value: TeleopState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, TeleopState):
+      return [False, "state must be of type TeleopState for StartTeleopResponse, 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_success(self.success)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_start_teleop_response(data: object):
+  return StartTeleopResponse(
+    success=parse_bool(data["success"]) if "success" in data and data.get("success") is not None else None,
+    state=parse_teleop_state(data["state"]) if "state" in data and data.get("state") is not None else None,
+  )
+
+def serialize_start_teleop_response(data: StartTeleopResponse) -> object:
+  return {
+    "success": None if data.success is None else serialize_bool(data.success),
+    "state": None if data.state is None else serialize_teleop_state(data.state),
+  }
+
+@dataclass
+class StopTeleopResponse:
+  """Response to stop teleoperation"""
+  success: Union[bool, None] = None
+  state: Union[TeleopState, None] = None
+
+  def validate_success(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "success must be of type bool for StopTeleopResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_state(self, value: TeleopState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, TeleopState):
+      return [False, "state must be of type TeleopState for StopTeleopResponse, 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_success(self.success)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_stop_teleop_response(data: object):
+  return StopTeleopResponse(
+    success=parse_bool(data["success"]) if "success" in data and data.get("success") is not None else None,
+    state=parse_teleop_state(data["state"]) if "state" in data and data.get("state") is not None else None,
+  )
+
+def serialize_stop_teleop_response(data: StopTeleopResponse) -> object:
+  return {
+    "success": None if data.success is None else serialize_bool(data.success),
+    "state": None if data.state is None else serialize_teleop_state(data.state),
+  }
+