standardbots 2.0.0.dev1745455051__py3-none-any.whl → 2.0.0.dev1750459189__py3-none-any.whl

standardbots/auto_generated/apis.py

@@ -354,6 +354,374 @@ class Default:
                 if parsed is None and (is_user_error or is_unavailable):
                     parsed = models.parse_error_response(json.loads(response.data))
 
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+    class Payload:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def set_payload(
+            self,
+            body: models.PayloadStateRequest,
+        ) -> Response[
+            Union[
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
+            None
+        ]:
+            """
+            Set a value for the mass being carried by the robot's end-effector.
+
+            """
+            path = "/api/v1/payload"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_payload_state_request(body)),
+                )
+                parsed = None
+                if response.status == 400:
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def get_payload(
+            self,
+        ) -> Response[
+            Union[
+                models.PayloadStateResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.PayloadStateResponse
+        ]:
+            """
+            Get the current mass value being carried by the robot&#x27;s end-effector.
+
+            """
+            path = "/api/v1/payload"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_payload_state_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+    class Recorder:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_recorder_state(
+            self,
+        ) -> Response[
+            Union[
+                models.RecorderState,
+                models.ErrorResponse,
+                None
+            ],
+            models.RecorderState
+        ]:
+            """
+            Get the state of the recorder
+            """
+            path = "/api/v1/recorder/state"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_recorder_state(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def update_recording(
+            self,
+            body: models.RecorderConfig,
+        ) -> Response[
+            Union[
+                models.UpdateRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.UpdateRecordingResponse
+        ]:
+            """
+            Update recording configuration
+            """
+            path = "/api/v1/recorder/update"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_recorder_config(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_update_recording_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def enable_recorder_bot(
+            self,
+            body: models.ToggleRecorderBotRequest,
+        ) -> Response[
+            Union[
+                models.UpdateRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.UpdateRecordingResponse
+        ]:
+            """
+            Enable or disable a secondary bot
+            """
+            path = "/api/v1/recorder/set-bot-enabled"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_toggle_recorder_bot_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_update_recording_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def start_recording(
+            self,
+            body: models.StartRecordingRequest,
+        ) -> Response[
+            Union[
+                models.StartRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.StartRecordingResponse
+        ]:
+            """
+            Start recording movement and camera data
+            """
+            path = "/api/v1/recorder/start"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_start_recording_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_start_recording_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def stop_recording(
+            self,
+            body: models.StopRecordingRequest,
+        ) -> Response[
+            Union[
+                models.StopRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.StopRecordingResponse
+        ]:
+            """
+            Stop recording movement and camera data
+            """
+            path = "/api/v1/recorder/stop"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_stop_recording_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_stop_recording_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def save_recording(
+            self,
+            body: models.SaveRecordingRequest,
+        ) -> Response[
+            Union[
+                models.SaveRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.SaveRecordingResponse
+        ]:
+            """
+            Save recording to marvin app
+            """
+            path = "/api/v1/recorder/save"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_save_recording_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_save_recording_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
                 return Response(
                     parsed,
                     response.status,
@@ -373,29 +741,396 @@ class Default:
             self._request_manager = request_manager
 
 
-        def get_sensors(
+        def get_sensors(
+            self,
+        ) -> Response[
+            Union[
+                models.SensorsConfiguration,
+                models.ErrorResponse,
+                None
+            ],
+            models.SensorsConfiguration
+        ]:
+            """
+            Get the current state of all sensors
+            """
+            path = "/api/v1/equipment/custom/sensors"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_sensors_configuration(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+    class Space:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def list_planes(
+            self,
+            limit: int,
+            offset: int,
+        ) -> Response[
+            Union[
+                models.PlanesPaginatedResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.PlanesPaginatedResponse
+        ]:
+            """
+            List Planes
+            """
+            path = "/api/v1/space/planes"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    fields={
+                        "limit": models.serialize_i_64(limit),
+                        "offset": models.serialize_i_64(offset),
+                    }
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_planes_paginated_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+    class Teleop:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_state(
+            self,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Get the state of the teleop
+            """
+            path = "/api/v1/teleop/state"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def enable_bot(
+            self,
+            body: models.ToggleTeleopBotRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Enable or disable a secondary bot
+            """
+            path = "/api/v1/teleop/set-bot-enabled"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_toggle_teleop_bot_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def set_teleop_config(
+            self,
+            body: models.TeleopConfig,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Set teleop config parameters
+            """
+            path = "/api/v1/teleop/set-config"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_teleop_config(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def start_teleop(
+            self,
+        ) -> Response[
+            Union[
+                models.StartTeleopResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.StartTeleopResponse
+        ]:
+            """
+            Start teleoperation
+            """
+            path = "/api/v1/teleop/start"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_start_teleop_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def stop_teleop(
+            self,
+        ) -> Response[
+            Union[
+                models.StopTeleopResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.StopTeleopResponse
+        ]:
+            """
+            Stop recording movement and camera data
+            """
+            path = "/api/v1/teleop/stop"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_stop_teleop_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def set_ratio_control(
+            self,
+            body: models.SetRatioControlRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Set ratio control parameters
+            """
+            path = "/api/v1/teleop/set-ratio-control"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_set_ratio_control_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+    class Webrtc:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def send_message(
             self,
+            body: models.SendMessageRequest,
         ) -> Response[
-            Union[
-                models.SensorsConfiguration,
-                models.ErrorResponse,
-                None
-            ],
-            models.SensorsConfiguration
+            None,
+            None
         ]:
             """
-            Get the current state of all sensors
+            Send a WebRTC signaling message
             """
-            path = "/api/v1/equipment/custom/sensors"
+            path = "/api/v1/webrtc/message"
             try:
                 response = self._request_manager.request(
-                    "GET",
+                    "POST",
                     path,
                     headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_send_message_request(body)),
                 )
                 parsed = None
-                if response.status == 200:
-                    parsed = models.parse_sensors_configuration(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -416,40 +1151,35 @@ class Default:
                     503,
                     None
                 )
-    class Space:
-        def __init__(self, request_manager: RequestManager):
-            self._request_manager = request_manager
-
-
-        def list_planes(
+        def get_messages(
             self,
-            limit: int,
-            offset: int,
+            base_url: str,
+            client_id: str,
         ) -> Response[
             Union[
-                models.PlanesPaginatedResponse,
+                models.GetMessagesResponse,
                 models.ErrorResponse,
                 None
             ],
-            models.PlanesPaginatedResponse
+            models.GetMessagesResponse
         ]:
             """
-            List Planes
+            Get pending WebRTC signaling messages
             """
-            path = "/api/v1/space/planes"
+            path = "/api/v1/webrtc/messages"
             try:
                 response = self._request_manager.request(
                     "GET",
                     path,
                     headers=self._request_manager.json_headers(),
                     fields={
-                        "limit": models.serialize_i_64(limit),
-                        "offset": models.serialize_i_64(offset),
+                        "baseUrl": models.serialize_str(base_url),
+                        "clientId": models.serialize_str(client_id),
                     }
                 )
                 parsed = None
                 if response.status == 200:
-                    parsed = models.parse_planes_paginated_response(json.loads(response.data))
+                    parsed = models.parse_get_messages_response(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -473,15 +1203,23 @@ class Default:
 
     calibration: Calibration
     equipment: Equipment
+    payload: Payload
+    recorder: Recorder
     sensors: Sensors
     space: Space
+    teleop: Teleop
+    webrtc: Webrtc
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
         self.calibration = Default.Calibration(request_manager)
         self.equipment = Default.Equipment(request_manager)
+        self.payload = Default.Payload(request_manager)
+        self.recorder = Default.Recorder(request_manager)
         self.sensors = Default.Sensors(request_manager)
         self.space = Default.Space(request_manager)
+        self.teleop = Default.Teleop(request_manager)
+        self.webrtc = Default.Webrtc(request_manager)
 
 class Movement:
     _request_manager: RequestManager
@@ -783,14 +1521,113 @@ class Movement:
                     503,
                     None
                 )
+    class PositionControlled:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def set_arm_position_controlled(
+            self,
+            body: models.ArmPositionUpdateControlledRequest,
+        ) -> Response[
+            Union[
+                models.SetArmPositionControlledResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.SetArmPositionControlledResponse
+        ]:
+            """
+            Control the position of the RO1 Robot arm in a controlled manner. This endpoint will return once the movement is initiated. The client should then call the heartbeat endpoint every 300ms to continue the movement and get its status. The robot should be idle before calling this endpoint.
+
+            """
+            path = "/api/v1/movement/position/arm/controlled"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_arm_position_update_controlled_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_set_arm_position_controlled_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def send_heartbeat(
+            self,
+            command_id: str,
+        ) -> Response[
+            Union[
+                models.SetArmPositionControlledResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.SetArmPositionControlledResponse
+        ]:
+            """
+            Use this endpoint to send a heartbeat for the current movement. This assumes that the client has already called the &quot;Set Arm Position With Heartbeat&quot; endpoint and that the movement is in progress. This heartbeat should be sent every 300ms. The robot should be executing a movement when calling this endpoint.
+
+            """
+            path = "/api/v1/movement/position/arm/controlled/{command_id}/heartbeat"
+            path = path.replace("{command_id}", str(command_id))
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_set_arm_position_controlled_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
 
     brakes: Brakes
     position: Position
+    position_controlled: PositionControlled
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
         self.brakes = Movement.Brakes(request_manager)
         self.position = Movement.Position(request_manager)
+        self.position_controlled = Movement.PositionControlled(request_manager)
 
 class Camera:
     _request_manager: RequestManager
@@ -1011,16 +1848,66 @@ class Camera:
                     503,
                     None
                 )
+    class Bot:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_connected_cameras(
+            self,
+        ) -> Response[
+            Union[
+                models.CameraDeviceList,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraDeviceList
+        ]:
+            """
+            Retrieve the list of connected camera devices from camera bot.
+            """
+            path = "/api/v1/cameras/connected"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_device_list(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
 
     data: Data
     settings: Settings
     status: Status
+    bot: Bot
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
         self.data = Camera.Data(request_manager)
         self.settings = Camera.Settings(request_manager)
         self.status = Camera.Status(request_manager)
+        self.bot = Camera.Bot(request_manager)
 
 class Faults:
     _request_manager: RequestManager
@@ -1393,6 +2280,112 @@ class IO:
         self.control = IO.Control(request_manager)
         self.status = IO.Status(request_manager)
 
+class Messenger:
+    _request_manager: RequestManager
+    class Peers:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def register_peer(
+            self,
+            body: models.RegisterPeerRequest,
+        ) -> Response[
+            Union[
+                models.RegisterPeerResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.RegisterPeerResponse
+        ]:
+            """
+            Register a new peer with the messenger system.
+
+            """
+            path = "/api/v1/messenger/peers"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_register_peer_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_register_peer_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def unregister_peer(
+            self,
+            body: models.UnregisterPeerRequest,
+        ) -> Response[
+            Union[
+                models.UnregisterPeerResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.UnregisterPeerResponse
+        ]:
+            """
+            Unregister an existing peer from the messenger system.
+
+            """
+            path = "/api/v1/messenger/peers"
+            try:
+                response = self._request_manager.request(
+                    "DELETE",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_unregister_peer_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_unregister_peer_response(json.loads(response.data))
+
+                is_user_error = response.status >= 400 and response.status <= 500
+                is_unavailable = response.status == 503
+                if parsed is None and (is_user_error or is_unavailable):
+                    parsed = models.parse_error_response(json.loads(response.data))
+
+                return Response(
+                    parsed,
+                    response.status,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+
+    peers: Peers
+
+    def __init__(self, request_manager: RequestManager):
+        self._request_manager = request_manager
+        self.peers = Messenger.Peers(request_manager)
+
 class Poses:
     _request_manager: RequestManager
     class ConstructPose:
@@ -2717,6 +3710,7 @@ class StandardBotsRobot(Default):
     general: General
     chat_gpt: ChatGPT
     io: IO
+    messenger: Messenger
     poses: Poses
     recovery: Recovery
     ros: ROS
@@ -2741,6 +3735,7 @@ class StandardBotsRobot(Default):
         self.general = General(self._request_manager)
         self.chat_gpt = ChatGPT(self._request_manager)
         self.io = IO(self._request_manager)
+        self.messenger = Messenger(self._request_manager)
         self.poses = Poses(self._request_manager)
         self.recovery = Recovery(self._request_manager)
         self.ros = ROS(self._request_manager)