standardbots 2.0.0.dev1744991656__py3-none-any.whl → 2.0.0.dev1744991699__py3-none-any.whl

standardbots/auto_generated/models.py

@@ -1870,6 +1870,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"""
@@ -2141,6 +2201,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`"""
@@ -2406,6 +2482,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"""
@@ -2544,6 +2680,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`"""
@@ -2603,6 +2769,148 @@ 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):
+  Active = "active"
+  """Enum Active = `active`"""
+  Inactive = "inactive"
+  """Enum Inactive = `inactive`"""
+  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.
@@ -4754,6 +5062,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."""
@@ -5153,22 +5551,157 @@ def serialize_status_health_response(data: StatusHealthResponse) -> object:
   }
 
 @dataclass
-class ArmPositionUpdateRequestResponseEventStreamDetails:
-  """Specify how the response should be sent
-"""
-  subscriptions: Union[ArmPositionUpdateRequestResponseEventStreamSubscriptionsList, None] = None
+class SaveRecordingResponse:
+  """Response to save recording to marvin app"""
+  uploadId: Union[str, None] = None
+  errors: Union[StringArray, None] = None
 
-  def validate_subscriptions(self, value: ArmPositionUpdateRequestResponseEventStreamSubscriptionsList) -> Tuple[bool, str]:
+  def validate_uploadId(self, value: str) -> Tuple[bool, str]:
     if value is None:
-      return [False, "subscriptions is required for ArmPositionUpdateRequestResponseEventStreamDetails"]
+      return [True, ""]
 
-    if not (isinstance(value, list) and all(((isinstance(x, str) and ArmPositionUpdateRequestResponseEventStreamSubscriptionKindEnum in ['all', 'events', 'positions']) or isinstance(x, ArmPositionUpdateRequestResponseEventStreamSubscriptionKindEnum)) for x in value)):
-      return [False, "subscriptions must be of type ArmPositionUpdateRequestResponseEventStreamSubscriptionsList for ArmPositionUpdateRequestResponseEventStreamDetails, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "uploadId must be of type str for SaveRecordingResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
+  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
+  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_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 ['active', 'inactive', '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_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,
+    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),
+    "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
+"""
+  subscriptions: Union[ArmPositionUpdateRequestResponseEventStreamSubscriptionsList, None] = None
+
+  def validate_subscriptions(self, value: ArmPositionUpdateRequestResponseEventStreamSubscriptionsList) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "subscriptions is required for ArmPositionUpdateRequestResponseEventStreamDetails"]
+
+    if not (isinstance(value, list) and all(((isinstance(x, str) and ArmPositionUpdateRequestResponseEventStreamSubscriptionKindEnum in ['all', 'events', 'positions']) or isinstance(x, ArmPositionUpdateRequestResponseEventStreamSubscriptionKindEnum)) for x in value)):
+      return [False, "subscriptions must be of type ArmPositionUpdateRequestResponseEventStreamSubscriptionsList for ArmPositionUpdateRequestResponseEventStreamDetails, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
     is_valid, error_str = self.validate_subscriptions(self.subscriptions)
     if not is_valid:
       raise TypeError(error_str)
@@ -5690,6 +6223,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"""
@@ -5968,6 +6546,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."""
@@ -6058,6 +6644,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
@@ -6436,6 +7030,141 @@ def parse_position_and_orientation_list(data: object) -> PositionAndOrientationL
 def serialize_position_and_orientation_list(data: PositionAndOrientationList) -> List[object]:
   return [serialize_position_and_orientation(item) for item in data]
 
+@dataclass
+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"""
@@ -6684,6 +7413,126 @@ def serialize_arm_position_update_request(data: ArmPositionUpdateRequest) -> obj
     "speed_profile": None if data.speed_profile is None else serialize_speed_profile(data.speed_profile),
   }
 
+@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
+
+  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 ['active', 'inactive', 'error']) or isinstance(value, TeleopStatus)):
+      return [False, "status must be of type TeleopStatus 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)
+
+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,
+  )
+
+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),
+  }
+
 @dataclass
 class SpacesPaginatedResponse:
   """Paginated response containing space data"""
@@ -6722,3 +7571,243 @@ 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 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"""
+  state: Union[TeleopState, None] = None
+
+  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_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_stop_teleop_response(data: object):
+  return StopTeleopResponse(
+    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 {
+    "state": None if data.state is None else serialize_teleop_state(data.state),
+  }
+