standardbots 2.20250512.49__py3-none-any.whl → 2.20250801.2__py3-none-any.whl

standardbots/auto_generated/models.py

@@ -327,6 +327,66 @@ def parse_brakes_state_enum(data: object) -> BrakesStateEnum:
 def serialize_brakes_state_enum(data: Union[BrakesStateEnum, str]) -> object:
   return BrakesStateEnum(data).value
 
+@dataclass
+class CameraConfiguration:
+  """Configuration settings for a camera."""
+  fps: Union[int, None] = None
+  width: Union[int, None] = None
+  height: Union[int, None] = None
+
+  def validate_fps(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "fps must be of type int for CameraConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_width(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "width must be of type int for CameraConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_height(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "height must be of type int for CameraConfiguration, 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_fps(self.fps)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_width(self.width)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_height(self.height)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_configuration(data: object):
+  return CameraConfiguration(
+    fps=parse_u_32(data["fps"]) if "fps" in data and data.get("fps") is not None else None,
+    width=parse_u_32(data["width"]) if "width" in data and data.get("width") is not None else None,
+    height=parse_u_32(data["height"]) if "height" in data and data.get("height") is not None else None,
+  )
+
+def serialize_camera_configuration(data: CameraConfiguration) -> object:
+  return {
+    "fps": None if data.fps is None else serialize_u_32(data.fps),
+    "width": None if data.width is None else serialize_u_32(data.width),
+    "height": None if data.height is None else serialize_u_32(data.height),
+  }
+
 @dataclass
 class CameraIntrinsics:
   """Intrinsic parameters of the camera."""
@@ -612,6 +672,20 @@ def serialize_camera_status(data: CameraStatus) -> object:
     "message": None if data.message is None else serialize_str(data.message),
   }
 
+class CameraType(Enum):
+  UNKOWN = "UNKOWN"
+  """Enum UNKOWN = `UNKOWN`"""
+  REALSENSE = "REALSENSE"
+  """Enum REALSENSE = `REALSENSE`"""
+  LUXONIS = "LUXONIS"
+  """Enum LUXONIS = `LUXONIS`"""
+
+def parse_camera_type(data: object) -> CameraType:
+  return CameraType(data)
+
+def serialize_camera_type(data: Union[CameraType, str]) -> object:
+  return CameraType(data).value
+
 @dataclass
 class CartesianPose:
   """Cartesian pose
@@ -1111,6 +1185,109 @@ def serialize_environment_variable(data: EnvironmentVariable) -> object:
     "value": None if data.value is None else serialize_str(data.value),
   }
 
+@dataclass
+class EquipmentConfig:
+  """Equipment configuration
+"""
+  id: Union[str, None] = None
+  name: Union[str, None] = None
+  kind: Union[str, None] = None
+  is_enabled: Union[bool, None] = None
+  config: Union[str, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "id is required for EquipmentConfig"]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_name(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "name must be of type str for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_kind(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "kind is required for EquipmentConfig"]
+
+    if not isinstance(value, str):
+      return [False, "kind must be of type str for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_is_enabled(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "is_enabled is required for EquipmentConfig"]
+
+    if not isinstance(value, bool):
+      return [False, "is_enabled must be of type bool for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_config(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "config is required for EquipmentConfig"]
+
+    if not isinstance(value, str):
+      return [False, "config must be of type str for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_id(self.id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_name(self.name)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_kind(self.kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_is_enabled(self.is_enabled)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_config(self.config)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_equipment_config(data: object):
+  return EquipmentConfig(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
+    kind=parse_str(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    is_enabled=parse_bool(data["is_enabled"]) if "is_enabled" in data and data.get("is_enabled") is not None else None,
+    config=parse_str(data["config"]) if "config" in data and data.get("config") is not None else None,
+  )
+
+def serialize_equipment_config(data: EquipmentConfig) -> object:
+  return {
+    "id": serialize_str(data.id),
+    "name": None if data.name is None else serialize_str(data.name),
+    "kind": serialize_str(data.kind),
+    "is_enabled": serialize_bool(data.is_enabled),
+    "config": serialize_str(data.config),
+  }
+
+EquipmentKeyAssignments = Dict[str, str]
+
+def parse_equipment_key_assignments(data: object) -> EquipmentKeyAssignments:
+  return {
+    parse_str(key): parse_str(value) for key, value in data.items()
+  }
+
+def serialize_equipment_key_assignments(data: EquipmentKeyAssignments) -> object:
+  return {
+    serialize_str(key): serialize_str(value) for key, value in data.items()
+  }
+
 class ErrorEnum(Enum):
   AuthorizationRequired = "authorization_required"
   """Authorization required to access this resource"""
@@ -1946,6 +2123,81 @@ def serialize_payload_state_response(data: PayloadStateResponse) -> object:
     "mass": None if data.mass is None else serialize_f_64(data.mass),
   }
 
+@dataclass
+class Peer:
+  """Information about a registered messenger peer"""
+  id: Union[str, None] = None
+  host: Union[str, None] = None
+  requestPort: Union[int, None] = None
+  topicPort: Union[int, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "id is required for Peer"]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for Peer, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_host(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "host is required for Peer"]
+
+    if not isinstance(value, str):
+      return [False, "host must be of type str for Peer, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_requestPort(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "requestPort is required for Peer"]
+
+    if not isinstance(value, int):
+      return [False, "requestPort must be of type int for Peer, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_topicPort(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "topicPort is required for Peer"]
+
+    if not isinstance(value, int):
+      return [False, "topicPort must be of type int for Peer, 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_host(self.host)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_requestPort(self.requestPort)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_topicPort(self.topicPort)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_peer(data: object):
+  return Peer(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    host=parse_str(data["host"]) if "host" in data and data.get("host") is not None else None,
+    requestPort=parse_i_32(data["requestPort"]) if "requestPort" in data and data.get("requestPort") is not None else None,
+    topicPort=parse_i_32(data["topicPort"]) if "topicPort" in data and data.get("topicPort") is not None else None,
+  )
+
+def serialize_peer(data: Peer) -> object:
+  return {
+    "id": serialize_str(data.id),
+    "host": serialize_str(data.host),
+    "requestPort": serialize_i_32(data.requestPort),
+    "topicPort": serialize_i_32(data.topicPort),
+  }
+
 @dataclass
 class Plane:
   """Plane in 3D space"""
@@ -2226,6 +2478,8 @@ class RecorderStatus(Enum):
   """Enum Error = `error`"""
   Complete = "complete"
   """Enum Complete = `complete`"""
+  Initializing = "initializing"
+  """Enum Initializing = `initializing`"""
 
 def parse_recorder_status(data: object) -> RecorderStatus:
   return RecorderStatus(data)
@@ -2251,6 +2505,141 @@ def parse_recovery_type_enum(data: object) -> RecoveryTypeEnum:
 def serialize_recovery_type_enum(data: Union[RecoveryTypeEnum, str]) -> object:
   return RecoveryTypeEnum(data).value
 
+@dataclass
+class RegisterPeerRequest:
+  """Request to register a new peer with the messenger system"""
+  targetId: Union[str, None] = None
+  senderId: Union[str, None] = None
+  host: Union[str, None] = None
+  requestPort: Union[int, None] = None
+  topicPort: Union[int, None] = None
+
+  def validate_targetId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "targetId is required for RegisterPeerRequest"]
+
+    if not isinstance(value, str):
+      return [False, "targetId must be of type str for RegisterPeerRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_senderId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "senderId is required for RegisterPeerRequest"]
+
+    if not isinstance(value, str):
+      return [False, "senderId must be of type str for RegisterPeerRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_host(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "host is required for RegisterPeerRequest"]
+
+    if not isinstance(value, str):
+      return [False, "host must be of type str for RegisterPeerRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_requestPort(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "requestPort is required for RegisterPeerRequest"]
+
+    if not isinstance(value, int):
+      return [False, "requestPort must be of type int for RegisterPeerRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_topicPort(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "topicPort is required for RegisterPeerRequest"]
+
+    if not isinstance(value, int):
+      return [False, "topicPort must be of type int for RegisterPeerRequest, 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_targetId(self.targetId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_senderId(self.senderId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_host(self.host)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_requestPort(self.requestPort)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_topicPort(self.topicPort)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_register_peer_request(data: object):
+  return RegisterPeerRequest(
+    targetId=parse_str(data["targetId"]) if "targetId" in data and data.get("targetId") is not None else None,
+    senderId=parse_str(data["senderId"]) if "senderId" in data and data.get("senderId") is not None else None,
+    host=parse_str(data["host"]) if "host" in data and data.get("host") is not None else None,
+    requestPort=parse_i_32(data["requestPort"]) if "requestPort" in data and data.get("requestPort") is not None else None,
+    topicPort=parse_i_32(data["topicPort"]) if "topicPort" in data and data.get("topicPort") is not None else None,
+  )
+
+def serialize_register_peer_request(data: RegisterPeerRequest) -> object:
+  return {
+    "targetId": serialize_str(data.targetId),
+    "senderId": serialize_str(data.senderId),
+    "host": serialize_str(data.host),
+    "requestPort": serialize_i_32(data.requestPort),
+    "topicPort": serialize_i_32(data.topicPort),
+  }
+
+@dataclass
+class RegisterPeerResponse:
+  """Response after attempting to register a peer"""
+  success: Union[bool, None] = None
+  message: Union[str, None] = None
+
+  def validate_success(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "success is required for RegisterPeerResponse"]
+
+    if not isinstance(value, bool):
+      return [False, "success must be of type bool for RegisterPeerResponse, 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 RegisterPeerResponse, 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_message(self.message)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_register_peer_response(data: object):
+  return RegisterPeerResponse(
+    success=parse_bool(data["success"]) if "success" in data and data.get("success") 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_register_peer_response(data: RegisterPeerResponse) -> object:
+  return {
+    "success": serialize_bool(data.success),
+    "message": None if data.message is None else serialize_str(data.message),
+  }
+
 class RobotControlModeEnum(Enum):
   Api = "api"
   """The robot is controlled via the Standard Bots Robot API (this API)"""
@@ -2659,11 +3048,116 @@ def serialize_sensor(data: Sensor) -> object:
   }
 
 @dataclass
-class SetRatioControlRequest:
-  """Request to set ratio control parameters"""
-  enabled: Union[bool, None] = None
-  value: Union[float, None] = None
-
+class SensorConfig:
+  """Config of the sensor"""
+  id: Union[str, None] = None
+  equipmentName: Union[str, None] = None
+  sensorType: Union[str, None] = None
+  dataType: Union[str, None] = None
+  isSecondary: Union[bool, None] = None
+  metadata: Union[str, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for SensorConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_equipmentName(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "equipmentName must be of type str for SensorConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_sensorType(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "sensorType must be of type str for SensorConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_dataType(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "dataType must be of type str for SensorConfig, 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 SensorConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_metadata(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "metadata must be of type str for SensorConfig, 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_equipmentName(self.equipmentName)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_sensorType(self.sensorType)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_dataType(self.dataType)
+    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_metadata(self.metadata)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_sensor_config(data: object):
+  return SensorConfig(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    equipmentName=parse_str(data["equipmentName"]) if "equipmentName" in data and data.get("equipmentName") is not None else None,
+    sensorType=parse_str(data["sensorType"]) if "sensorType" in data and data.get("sensorType") is not None else None,
+    dataType=parse_str(data["dataType"]) if "dataType" in data and data.get("dataType") is not None else None,
+    isSecondary=parse_bool(data["isSecondary"]) if "isSecondary" in data and data.get("isSecondary") is not None else None,
+    metadata=parse_str(data["metadata"]) if "metadata" in data and data.get("metadata") is not None else None,
+  )
+
+def serialize_sensor_config(data: SensorConfig) -> object:
+  return {
+    "id": None if data.id is None else serialize_str(data.id),
+    "equipmentName": None if data.equipmentName is None else serialize_str(data.equipmentName),
+    "sensorType": None if data.sensorType is None else serialize_str(data.sensorType),
+    "dataType": None if data.dataType is None else serialize_str(data.dataType),
+    "isSecondary": None if data.isSecondary is None else serialize_bool(data.isSecondary),
+    "metadata": None if data.metadata is None else serialize_str(data.metadata),
+  }
+
+@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, ""]
@@ -2703,6 +3197,30 @@ def serialize_set_ratio_control_request(data: SetRatioControlRequest) -> object:
     "value": None if data.value is None else serialize_f_64(data.value),
   }
 
+class SignalMessageType(Enum):
+  JoinRoom = "join-room"
+  """Enum JoinRoom = `join-room`"""
+  Connect = "connect"
+  """Enum Connect = `connect`"""
+  Join = "join"
+  """Enum Join = `join`"""
+  Leave = "leave"
+  """Enum Leave = `leave`"""
+  Offer = "offer"
+  """Enum Offer = `offer`"""
+  Answer = "answer"
+  """Enum Answer = `answer`"""
+  IceCandidate = "ice-candidate"
+  """Enum IceCandidate = `ice-candidate`"""
+  Heartbeat = "heartbeat"
+  """Enum Heartbeat = `heartbeat`"""
+
+def parse_signal_message_type(data: object) -> SignalMessageType:
+  return SignalMessageType(data)
+
+def serialize_signal_message_type(data: Union[SignalMessageType, str]) -> object:
+  return SignalMessageType(data).value
+
 SkillsList = List[str]
 
 def parse_skills_list(data: object) -> SkillsList:
@@ -2741,36 +3259,6 @@ 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`"""
@@ -3022,6 +3510,96 @@ def serialize_trigger_fault_request(data: TriggerFaultRequest) -> object:
     "isRecoverable": None if data.isRecoverable is None else serialize_bool(data.isRecoverable),
   }
 
+@dataclass
+class UnregisterPeerRequest:
+  """Request to unregister an existing peer from the messenger system"""
+  targetId: Union[str, None] = None
+  senderId: Union[str, None] = None
+
+  def validate_targetId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "targetId is required for UnregisterPeerRequest"]
+
+    if not isinstance(value, str):
+      return [False, "targetId must be of type str for UnregisterPeerRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_senderId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "senderId is required for UnregisterPeerRequest"]
+
+    if not isinstance(value, str):
+      return [False, "senderId must be of type str for UnregisterPeerRequest, 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_targetId(self.targetId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_senderId(self.senderId)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_unregister_peer_request(data: object):
+  return UnregisterPeerRequest(
+    targetId=parse_str(data["targetId"]) if "targetId" in data and data.get("targetId") is not None else None,
+    senderId=parse_str(data["senderId"]) if "senderId" in data and data.get("senderId") is not None else None,
+  )
+
+def serialize_unregister_peer_request(data: UnregisterPeerRequest) -> object:
+  return {
+    "targetId": serialize_str(data.targetId),
+    "senderId": serialize_str(data.senderId),
+  }
+
+@dataclass
+class UnregisterPeerResponse:
+  """Response after attempting to unregister a peer"""
+  success: Union[bool, None] = None
+  message: Union[str, None] = None
+
+  def validate_success(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "success is required for UnregisterPeerResponse"]
+
+    if not isinstance(value, bool):
+      return [False, "success must be of type bool for UnregisterPeerResponse, 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 UnregisterPeerResponse, 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_message(self.message)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_unregister_peer_response(data: object):
+  return UnregisterPeerResponse(
+    success=parse_bool(data["success"]) if "success" in data and data.get("success") 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_unregister_peer_response(data: UnregisterPeerResponse) -> object:
+  return {
+    "success": serialize_bool(data.success),
+    "message": None if data.message is None else serialize_str(data.message),
+  }
+
 @dataclass
 class ArmPositionUpdateFailureEvent:
   """Move robot event when movement failed"""
@@ -3151,6 +3729,141 @@ def serialize_camera_frame_request(data: CameraFrameRequest) -> object:
     "camera_settings": None if data.camera_settings is None else serialize_camera_settings(data.camera_settings),
   }
 
+@dataclass
+class CameraDevice:
+  """Information about a camera device."""
+  id: Union[str, None] = None
+  name: Union[str, None] = None
+  label: Union[str, None] = None
+  type: Union[CameraType, None] = None
+  model_name: Union[str, None] = None
+  enabled: Union[bool, None] = None
+  ip_address: Union[str, None] = None
+  config: Union[CameraConfiguration, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for CameraDevice, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_name(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "name must be of type str for CameraDevice, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_label(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "label must be of type str for CameraDevice, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_type(self, value: CameraType) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and CameraType in ['UNKOWN', 'REALSENSE', 'LUXONIS']) or isinstance(value, CameraType)):
+      return [False, "type must be of type CameraType for CameraDevice, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_model_name(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "model_name must be of type str for CameraDevice, 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 CameraDevice, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_ip_address(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "ip_address must be of type str for CameraDevice, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_config(self, value: CameraConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, CameraConfiguration):
+      return [False, "config must be of type CameraConfiguration for CameraDevice, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_id(self.id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_name(self.name)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_label(self.label)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_type(self.type)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_model_name(self.model_name)
+    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)
+    is_valid, error_str = self.validate_ip_address(self.ip_address)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_config(self.config)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_device(data: object):
+  return CameraDevice(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
+    label=parse_str(data["label"]) if "label" in data and data.get("label") is not None else None,
+    type=parse_camera_type(data["type"]) if "type" in data and data.get("type") is not None else None,
+    model_name=parse_str(data["model_name"]) if "model_name" in data and data.get("model_name") is not None else None,
+    enabled=parse_bool(data["enabled"]) if "enabled" in data and data.get("enabled") is not None else None,
+    ip_address=parse_str(data["ip_address"]) if "ip_address" in data and data.get("ip_address") is not None else None,
+    config=parse_camera_configuration(data["config"]) if "config" in data and data.get("config") is not None else None,
+  )
+
+def serialize_camera_device(data: CameraDevice) -> object:
+  return {
+    "id": None if data.id is None else serialize_str(data.id),
+    "name": None if data.name is None else serialize_str(data.name),
+    "label": None if data.label is None else serialize_str(data.label),
+    "type": None if data.type is None else serialize_camera_type(data.type),
+    "model_name": None if data.model_name is None else serialize_str(data.model_name),
+    "enabled": None if data.enabled is None else serialize_bool(data.enabled),
+    "ip_address": None if data.ip_address is None else serialize_str(data.ip_address),
+    "config": None if data.config is None else serialize_camera_configuration(data.config),
+  }
+
 @dataclass
 class CartesianOffsetResponse:
   """Response with the cartesian offset value
@@ -3435,6 +4148,59 @@ def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
 def serialize_environment_variables_list(data: EnvironmentVariablesList) -> List[object]:
   return [serialize_environment_variable(item) for item in data]
 
+EquipmentConfigList = List[EquipmentConfig]
+
+def parse_equipment_config_list(data: object) -> EquipmentConfigList:
+  return [parse_equipment_config(item) for item in data]
+
+def serialize_equipment_config_list(data: EquipmentConfigList) -> List[object]:
+  return [serialize_equipment_config(item) for item in data]
+
+@dataclass
+class StartRecordingRequest:
+  """Request to start recording movement and camera data"""
+  startTime: Union[str, None] = None
+  equipmentKeyAssignments: Union[EquipmentKeyAssignments, 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 validate_equipmentKeyAssignments(self, value: EquipmentKeyAssignments) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "equipmentKeyAssignments must be of type EquipmentKeyAssignments 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)
+    is_valid, error_str = self.validate_equipmentKeyAssignments(self.equipmentKeyAssignments)
+    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,
+    equipmentKeyAssignments=parse_equipment_key_assignments(data["equipmentKeyAssignments"]) if "equipmentKeyAssignments" in data and data.get("equipmentKeyAssignments") 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),
+    "equipmentKeyAssignments": None if data.equipmentKeyAssignments is None else serialize_equipment_key_assignments(data.equipmentKeyAssignments),
+  }
+
 @dataclass
 class ErrorResponse:
   """Error Response"""
@@ -5029,6 +5795,14 @@ def serialize_on_robot_3_fg_15_gripper_configuration(data: OnRobot3FG15GripperCo
     "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
   }
 
+PeerList = List[Peer]
+
+def parse_peer_list(data: object) -> PeerList:
+  return [parse_peer(item) for item in data]
+
+def serialize_peer_list(data: PeerList) -> List[object]:
+  return [serialize_peer(item) for item in data]
+
 PlanesList = List[Plane]
 
 def parse_planes_list(data: object) -> PlanesList:
@@ -5127,96 +5901,6 @@ 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."""
@@ -5519,11 +6203,109 @@ def serialize_play_routine_request(data: PlayRoutineRequest) -> object:
 
 SensorsList = List[Sensor]
 
-def parse_sensors_list(data: object) -> SensorsList:
-  return [parse_sensor(item) for item in data]
+def parse_sensors_list(data: object) -> SensorsList:
+  return [parse_sensor(item) for item in data]
+
+def serialize_sensors_list(data: SensorsList) -> List[object]:
+  return [serialize_sensor(item) for item in data]
+
+SensorConfigList = List[SensorConfig]
+
+def parse_sensor_config_list(data: object) -> SensorConfigList:
+  return [parse_sensor_config(item) for item in data]
+
+def serialize_sensor_config_list(data: SensorConfigList) -> List[object]:
+  return [serialize_sensor_config(item) for item in data]
+
+@dataclass
+class SignalMessage:
+  """WebRTC signaling message"""
+  type: Union[SignalMessageType, None] = None
+  senderId: Union[str, None] = None
+  receiverId: Union[str, None] = None
+  roomId: Union[str, None] = None
+  data: Union[str, None] = None
+
+  def validate_type(self, value: SignalMessageType) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and SignalMessageType in ['join-room', 'connect', 'join', 'leave', 'offer', 'answer', 'ice-candidate', 'heartbeat']) or isinstance(value, SignalMessageType)):
+      return [False, "type must be of type SignalMessageType for SignalMessage, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_senderId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "senderId must be of type str for SignalMessage, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_receiverId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "receiverId must be of type str for SignalMessage, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_roomId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "roomId must be of type str for SignalMessage, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_data(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "data must be of type str for SignalMessage, 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_type(self.type)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_senderId(self.senderId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_receiverId(self.receiverId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_roomId(self.roomId)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_data(self.data)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_signal_message(data: object):
+  return SignalMessage(
+    type=parse_signal_message_type(data["type"]) if "type" in data and data.get("type") is not None else None,
+    senderId=parse_str(data["senderId"]) if "senderId" in data and data.get("senderId") is not None else None,
+    receiverId=parse_str(data["receiverId"]) if "receiverId" in data and data.get("receiverId") is not None else None,
+    roomId=parse_str(data["roomId"]) if "roomId" in data and data.get("roomId") is not None else None,
+    data=parse_str(data["data"]) if "data" in data and data.get("data") is not None else None,
+  )
 
-def serialize_sensors_list(data: SensorsList) -> List[object]:
-  return [serialize_sensor(item) for item in data]
+def serialize_signal_message(data: SignalMessage) -> object:
+  return {
+    "type": None if data.type is None else serialize_signal_message_type(data.type),
+    "senderId": None if data.senderId is None else serialize_str(data.senderId),
+    "receiverId": None if data.receiverId is None else serialize_str(data.receiverId),
+    "roomId": None if data.roomId is None else serialize_str(data.roomId),
+    "data": None if data.data is None else serialize_str(data.data),
+  }
 
 @dataclass
 class TextToSkillRequest:
@@ -5615,6 +6397,111 @@ def serialize_status_health_response(data: StatusHealthResponse) -> object:
     "build": None if data.build is None else serialize_status_version_data(data.build),
   }
 
+@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
+  errors: Union[StringArray, 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', 'initializing']) or isinstance(value, RecorderStatus)):
+      return [False, "status must be of type RecorderStatus for RecorderBotDetails, 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 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)
+    is_valid, error_str = self.validate_errors(self.errors)
+    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,
+    errors=parse_string_array(data["errors"]) if "errors" in data and data.get("errors") 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),
+    "errors": None if data.errors is None else serialize_string_array(data.errors),
+  }
+
 @dataclass
 class SaveRecordingResponse:
   """Response to save recording to marvin app"""
@@ -5811,6 +6698,14 @@ def serialize_arm_position_update_request_response_event_stream_details(data: Ar
     "subscriptions": serialize_arm_position_update_request_response_event_stream_subscriptions_list(data.subscriptions),
   }
 
+CameraDeviceArray = List[CameraDevice]
+
+def parse_camera_device_array(data: object) -> CameraDeviceArray:
+  return [parse_camera_device(item) for item in data]
+
+def serialize_camera_device_array(data: CameraDeviceArray) -> List[object]:
+  return [serialize_camera_device(item) for item in data]
+
 @dataclass
 class Routine:
   """Robot Routine containing steps to automate robot movement and operations"""
@@ -5871,6 +6766,37 @@ def serialize_routine(data: Routine) -> object:
     "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
   }
 
+@dataclass
+class GetEquipmentConfigResponse:
+  """Response to get the currently-configured equipment
+"""
+  equipment: Union[EquipmentConfigList, None] = None
+
+  def validate_equipment(self, value: EquipmentConfigList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, EquipmentConfig) for x in value)):
+      return [False, "equipment must be of type EquipmentConfigList for GetEquipmentConfigResponse, 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_equipment(self.equipment)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_get_equipment_config_response(data: object):
+  return GetEquipmentConfigResponse(
+    equipment=parse_equipment_config_list(data["equipment"]) if "equipment" in data and data.get("equipment") is not None else None,
+  )
+
+def serialize_get_equipment_config_response(data: GetEquipmentConfigResponse) -> object:
+  return {
+    "equipment": None if data.equipment is None else serialize_equipment_config_list(data.equipment),
+  }
+
 @dataclass
 class CalibrationData:
   """The result of a calibration"""
@@ -6641,14 +7567,6 @@ 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."""
@@ -6739,6 +7657,82 @@ def serialize_sensors_configuration(data: SensorsConfiguration) -> object:
     "sensors": None if data.sensors is None else serialize_sensors_list(data.sensors),
   }
 
+@dataclass
+class SendMessageRequest:
+  """Request to send a WebRTC signaling message"""
+  baseUrl: Union[str, None] = None
+  clientId: Union[str, None] = None
+  message: Union[SignalMessage, None] = None
+
+  def validate_baseUrl(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "baseUrl must be of type str for SendMessageRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_clientId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "clientId must be of type str for SendMessageRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_message(self, value: SignalMessage) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, SignalMessage):
+      return [False, "message must be of type SignalMessage for SendMessageRequest, 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_baseUrl(self.baseUrl)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_clientId(self.clientId)
+    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_send_message_request(data: object):
+  return SendMessageRequest(
+    baseUrl=parse_str(data["baseUrl"]) if "baseUrl" in data and data.get("baseUrl") is not None else None,
+    clientId=parse_str(data["clientId"]) if "clientId" in data and data.get("clientId") is not None else None,
+    message=parse_signal_message(data["message"]) if "message" in data and data.get("message") is not None else None,
+  )
+
+def serialize_send_message_request(data: SendMessageRequest) -> object:
+  return {
+    "baseUrl": None if data.baseUrl is None else serialize_str(data.baseUrl),
+    "clientId": None if data.clientId is None else serialize_str(data.clientId),
+    "message": None if data.message is None else serialize_signal_message(data.message),
+  }
+
+SignalMessageList = List[SignalMessage]
+
+def parse_signal_message_list(data: object) -> SignalMessageList:
+  return [parse_signal_message(item) for item in data]
+
+def serialize_signal_message_list(data: SignalMessageList) -> List[object]:
+  return [serialize_signal_message(item) for item in data]
+
+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]
+
 BotTeleopDetailsList = List[BotTeleopDetails]
 
 def parse_bot_teleop_details_list(data: object) -> BotTeleopDetailsList:
@@ -6793,6 +7787,36 @@ def serialize_arm_position_update_request_response_format(data: ArmPositionUpdat
     "event_stream": None if data.event_stream is None else serialize_arm_position_update_request_response_event_stream_details(data.event_stream),
   }
 
+@dataclass
+class CameraDeviceList:
+  """Object containing list of available cameras."""
+  cameras: Union[CameraDeviceArray, None] = None
+
+  def validate_cameras(self, value: CameraDeviceArray) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, CameraDevice) for x in value)):
+      return [False, "cameras must be of type CameraDeviceArray for CameraDeviceList, 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_cameras(self.cameras)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_device_list(data: object):
+  return CameraDeviceList(
+    cameras=parse_camera_device_array(data["cameras"]) if "cameras" in data and data.get("cameras") is not None else None,
+  )
+
+def serialize_camera_device_list(data: CameraDeviceList) -> object:
+  return {
+    "cameras": None if data.cameras is None else serialize_camera_device_array(data.cameras),
+  }
+
 RoutinesList = List[Routine]
 
 def parse_routines_list(data: object) -> RoutinesList:
@@ -7125,6 +8149,36 @@ 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 GetMessagesResponse:
+  """Response containing pending messages for a client"""
+  messages: Union[SignalMessageList, None] = None
+
+  def validate_messages(self, value: SignalMessageList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, SignalMessage) for x in value)):
+      return [False, "messages must be of type SignalMessageList for GetMessagesResponse, 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_messages(self.messages)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_get_messages_response(data: object):
+  return GetMessagesResponse(
+    messages=parse_signal_message_list(data["messages"]) if "messages" in data and data.get("messages") is not None else None,
+  )
+
+def serialize_get_messages_response(data: GetMessagesResponse) -> object:
+  return {
+    "messages": None if data.messages is None else serialize_signal_message_list(data.messages),
+  }
+
 @dataclass
 class RecorderConfig:
   """Config of the recorder"""
@@ -7133,6 +8187,8 @@ class RecorderConfig:
   taskId: Union[str, None] = None
   bots: Union[RecorderBotDetailsList, None] = None
   offset: Union[OffsetConfig, None] = None
+  sensors: Union[SensorConfigList, None] = None
+  equipmentKeyAssignments: Union[EquipmentKeyAssignments, None] = None
 
   def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
     if value is None:
@@ -7179,6 +8235,24 @@ class RecorderConfig:
 
     return [True, ""]
 
+  def validate_sensors(self, value: SensorConfigList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, SensorConfig) for x in value)):
+      return [False, "sensors must be of type SensorConfigList for RecorderConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_equipmentKeyAssignments(self, value: EquipmentKeyAssignments) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "equipmentKeyAssignments must be of type EquipmentKeyAssignments 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)
@@ -7196,6 +8270,12 @@ class RecorderConfig:
     is_valid, error_str = self.validate_offset(self.offset)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_sensors(self.sensors)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_equipmentKeyAssignments(self.equipmentKeyAssignments)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_recorder_config(data: object):
   return RecorderConfig(
@@ -7204,6 +8284,8 @@ def parse_recorder_config(data: object):
     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,
+    sensors=parse_sensor_config_list(data["sensors"]) if "sensors" in data and data.get("sensors") is not None else None,
+    equipmentKeyAssignments=parse_equipment_key_assignments(data["equipmentKeyAssignments"]) if "equipmentKeyAssignments" in data and data.get("equipmentKeyAssignments") is not None else None,
   )
 
 def serialize_recorder_config(data: RecorderConfig) -> object:
@@ -7213,6 +8295,8 @@ def serialize_recorder_config(data: RecorderConfig) -> object:
     "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),
+    "sensors": None if data.sensors is None else serialize_sensor_config_list(data.sensors),
+    "equipmentKeyAssignments": None if data.equipmentKeyAssignments is None else serialize_equipment_key_assignments(data.equipmentKeyAssignments),
   }
 
 @dataclass
@@ -7665,6 +8749,7 @@ class RecorderState:
   startTime: Union[str, None] = None
   recordingTime: Union[int, None] = None
   status: Union[RecorderStatus, None] = None
+  errors: Union[StringArray, None] = None
 
   def validate_config(self, value: RecorderConfig) -> Tuple[bool, str]:
     if value is None:
@@ -7697,11 +8782,20 @@ class RecorderState:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and RecorderStatus in ['not_recording', 'recording', 'error', 'complete']) or isinstance(value, RecorderStatus)):
+    if not ((isinstance(value, str) and RecorderStatus in ['not_recording', 'recording', 'error', 'complete', 'initializing']) or isinstance(value, RecorderStatus)):
       return [False, "status must be of type RecorderStatus for RecorderState, 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 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)
@@ -7716,6 +8810,9 @@ class RecorderState:
     is_valid, error_str = self.validate_status(self.status)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_errors(self.errors)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_recorder_state(data: object):
   return RecorderState(
@@ -7723,6 +8820,7 @@ def parse_recorder_state(data: object):
     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,
+    errors=parse_string_array(data["errors"]) if "errors" in data and data.get("errors") is not None else None,
   )
 
 def serialize_recorder_state(data: RecorderState) -> object:
@@ -7731,6 +8829,7 @@ def serialize_recorder_state(data: RecorderState) -> object:
     "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),
+    "errors": None if data.errors is None else serialize_string_array(data.errors),
   }
 
 @dataclass