standardbots 2.20250128.38__py3-none-any.whl → 2.20250417.1__py3-none-any.whl

standardbots/auto_generated/apis.py

@@ -85,11 +85,11 @@ class Default:
             self,
         ) -> Response[
             Union[
-                models.ActiveCalibrationResponse,
+                models.ActiveCalibrationContainer,
                 models.ErrorResponse,
                 None
             ],
-            models.ActiveCalibrationResponse
+            models.ActiveCalibrationContainer
         ]:
             """
             Get the active calibration for the robot.
@@ -104,7 +104,47 @@ class Default:
                 )
                 parsed = None
                 if response.status == 200:
-                    parsed = models.parse_active_calibration_response(json.loads(response.data))
+                    parsed = models.parse_active_calibration_container(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_active_calibration(
+            self,
+            body: models.ActiveCalibrationContainer,
+        ) -> Response[
+            None,
+            None
+        ]:
+            """
+            Set the active calibration for the robot.
+
+            """
+            path = "/api/v1/calibration/active"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_active_calibration_container(body)),
+                )
+                parsed = None
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -132,7 +172,7 @@ class Default:
         def onrobot_2fg7_move(
           self,
           value: Union[int, float],
-          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Inward,
+          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Internal,
           unit_kind: Union[str, models.LinearUnitKind] = models.LinearUnitKind.Millimeters
         ):
           """Move the robot to the onrobot_2fg7 position.
@@ -154,7 +194,7 @@ class Default:
         def onrobot_2fg7_grip(
           self,
           value: Union[int, float],
-          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Inward,
+          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Internal,
           unit_kind: Union[str, models.LinearUnitKind] = models.LinearUnitKind.Millimeters,
           force: Union[int, float] = 0.0,
           force_unit: Union[str, models.ForceUnitKind] = models.ForceUnitKind.Newtons
@@ -240,30 +280,637 @@ class Default:
                     dh_cgi=models.DHCGIGripperCommandRequest(
                         target_diameter, target_force, target_speed
                     ),
-                ),
-            )
-        
-
-        def control_gripper(
+                ),
+            )
+        
+
+        def control_gripper(
+            self,
+            body: models.GripperCommandRequest,
+        ) -> Response[
+            None,
+            None
+        ]:
+            """
+            Send commands to control the Gripper (End Effector) of the robot. The gripper can be any of Standard Bots supported grippers.
+
+            """
+            path = "/api/v1/equipment/end-effector/control"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_gripper_command_request(body)),
+                )
+                parsed = None
+
+                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_gripper_configuration(
+            self,
+        ) -> Response[
+            Union[
+                models.GripperConfiguration,
+                models.ErrorResponse,
+                None
+            ],
+            models.GripperConfiguration
+        ]:
+            """
+            Get the current gripper configuration
+
+            """
+            path = "/api/v1/equipment/end-effector/configuration"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_gripper_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 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&#x27;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,
+                    response
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+    class Sensors:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        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.GripperCommandRequest,
+            body: models.ToggleTeleopBotRequest,
         ) -> Response[
-            None,
-            None
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
         ]:
             """
-            Send commands to control the Gripper (End Effector) of the robot. The gripper can be any of Standard Bots supported grippers.
-
+            Enable or disable a secondary bot
             """
-            path = "/api/v1/equipment/end-effector/control"
+            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_gripper_command_request(body)),
+                    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
@@ -284,30 +931,31 @@ class Default:
                     503,
                     None
                 )
-        def get_gripper_configuration(
+        def set_teleop_config(
             self,
+            body: models.TeleopConfig,
         ) -> Response[
             Union[
-                models.GripperConfiguration,
+                models.TeleopState,
                 models.ErrorResponse,
                 None
             ],
-            models.GripperConfiguration
+            models.TeleopState
         ]:
             """
-            Get the current gripper configuration
-
+            Set teleop config parameters
             """
-            path = "/api/v1/equipment/end-effector/configuration"
+            path = "/api/v1/teleop/set-config"
             try:
                 response = self._request_manager.request(
-                    "GET",
+                    "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_gripper_configuration(json.loads(response.data))
+                    parsed = models.parse_teleop_state(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -328,34 +976,29 @@ class Default:
                     503,
                     None
                 )
-    class Sensors:
-        def __init__(self, request_manager: RequestManager):
-            self._request_manager = request_manager
-
-
-        def get_sensors(
+        def start_teleop(
             self,
         ) -> Response[
             Union[
-                models.SensorsConfiguration,
+                models.StartTeleopResponse,
                 models.ErrorResponse,
                 None
             ],
-            models.SensorsConfiguration
+            models.StartTeleopResponse
         ]:
             """
-            Get the current state of all sensors
+            Start teleoperation
             """
-            path = "/api/v1/equipment/custom/sensors"
+            path = "/api/v1/teleop/start"
             try:
                 response = self._request_manager.request(
-                    "GET",
+                    "POST",
                     path,
                     headers=self._request_manager.json_headers(),
                 )
                 parsed = None
                 if response.status == 200:
-                    parsed = models.parse_sensors_configuration(json.loads(response.data))
+                    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
@@ -376,40 +1019,74 @@ class Default:
                     503,
                     None
                 )
-    class Space:
-        def __init__(self, request_manager: RequestManager):
-            self._request_manager = request_manager
+        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))
 
-        def list_planes(
+                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,
-            limit: int,
-            offset: int,
+            body: models.SetRatioControlRequest,
         ) -> Response[
             Union[
-                models.PlanesPaginatedResponse,
+                models.TeleopState,
                 models.ErrorResponse,
                 None
             ],
-            models.PlanesPaginatedResponse
+            models.TeleopState
         ]:
             """
-            List Planes
+            Set ratio control parameters
             """
-            path = "/api/v1/space/planes"
+            path = "/api/v1/teleop/set-ratio-control"
             try:
                 response = self._request_manager.request(
-                    "GET",
+                    "POST",
                     path,
                     headers=self._request_manager.json_headers(),
-                    fields={
-                        "limit": models.serialize_i_64(limit),
-                        "offset": models.serialize_i_64(offset),
-                    }
+                    body=json.dumps(models.serialize_set_ratio_control_request(body)),
                 )
                 parsed = None
                 if response.status == 200:
-                    parsed = models.parse_planes_paginated_response(json.loads(response.data))
+                    parsed = models.parse_teleop_state(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -433,15 +1110,21 @@ class Default:
 
     calibration: Calibration
     equipment: Equipment
+    payload: Payload
+    recorder: Recorder
     sensors: Sensors
     space: Space
+    teleop: Teleop
 
     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)
 
 class Movement:
     _request_manager: RequestManager
@@ -476,6 +1159,7 @@ class Movement:
             Union[
                 models.BrakesState,
                 models.ErrorResponse,
+                models.ErrorResponse,
                 None
             ],
             models.BrakesState
@@ -495,6 +1179,8 @@ class Movement:
                 parsed = None
                 if response.status == 200:
                     parsed = models.parse_brakes_state(json.loads(response.data))
+                if response.status == 500:
+                    parsed = models.parse_error_response(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -740,14 +1426,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
@@ -764,7 +1549,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera. In JPEG format.
+            Retrieve the latest RGB frame from the camera as base64 string. In JPEG format.
             """
             path = "/api/v1/camera/frame/rgb"
             try:
@@ -798,8 +1583,12 @@ class Camera:
         def get_camera_intrinsics_color(
             self,
         ) -> Response[
-            None,
-            None
+            Union[
+                models.CameraIntrinsics,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraIntrinsics
         ]:
             """
             Retrieve the intrinsic parameters for the color camera.
@@ -812,6 +1601,8 @@ class Camera:
                     headers=self._request_manager.json_headers(),
                 )
                 parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_intrinsics(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -839,7 +1630,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera.
+            Retrieve the latest RGB frame from the camera as base64 string. In JPEG format.
             """
             path = "/api/v1/camera/stream/rgb"
             try:
@@ -914,14 +1705,64 @@ class Camera:
                     503,
                     None
                 )
+    class Status:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_camera_status(
+            self,
+        ) -> Response[
+            Union[
+                models.CameraStatus,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraStatus
+        ]:
+            """
+            Retrieve the current status of the camera.
+            """
+            path = "/api/v1/camera/status"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_status(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
 
     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)
 
 class Faults:
     _request_manager: RequestManager
@@ -1978,8 +2819,13 @@ class RoutineEditor:
             body: models.PlayRoutineRequest,
             routine_id: str,
         ) -> Response[
-            None,
-            None
+            Union[
+                models.PlayRoutineResponse,
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.PlayRoutineResponse
         ]:
             """
             Play a routine
@@ -1994,6 +2840,10 @@ class RoutineEditor:
                     body=json.dumps(models.serialize_play_routine_request(body)),
                 )
                 parsed = None
+                if response.status == 200:
+                    parsed = models.parse_play_routine_response(json.loads(response.data))
+                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
@@ -2018,11 +2868,15 @@ class RoutineEditor:
             self,
             routine_id: str,
         ) -> Response[
-            None,
+            Union[
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
             None
         ]:
             """
-            Pause a routine
+            Pause a routine. Routine must be running.
             """
             path = "/api/v1/routine-editor/routines/{routine_id}/pause"
             path = path.replace("{routine_id}", str(routine_id))
@@ -2033,6 +2887,8 @@ class RoutineEditor:
                     headers=self._request_manager.json_headers(),
                 )
                 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
@@ -2056,11 +2912,15 @@ class RoutineEditor:
         def stop(
             self,
         ) -> Response[
-            None,
+            Union[
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
             None
         ]:
             """
-            Stop running routine and all ongoing motions
+            Stop running routine and all ongoing motions. Routine must be running.
             """
             path = "/api/v1/routine-editor/stop"
             try:
@@ -2070,6 +2930,8 @@ class RoutineEditor:
                     headers=self._request_manager.json_headers(),
                 )
                 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
@@ -2344,7 +3206,7 @@ class RoutineEditor:
             models.RuntimeVariable
         ]:
             """
-            Returns current state of a variable
+            Returns current state of a variable. Routine must be running.
             """
             path = "/api/v1/routine-editor/variables/{variable_name}"
             path = path.replace("{variable_name}", str(variable_name))
@@ -2390,7 +3252,7 @@ class RoutineEditor:
             models.RuntimeVariable
         ]:
             """
-            Update the value of a variable
+            Update the value of a variable. Routine must be running.
             """
             path = "/api/v1/routine-editor/variables/{variable_name}"
             path = path.replace("{variable_name}", str(variable_name))