standardbots 2.20241003.42__py3-none-any.whl → 2.20241119.1__py3-none-any.whl

standardbots/auto_generated/models.py

@@ -142,8 +142,8 @@ class ArmPositionUpdateCanceledEvent:
 
 def parse_arm_position_update_canceled_event(data: object):
   return ArmPositionUpdateCanceledEvent(
-    kind=parse_str(data["kind"]) if "kind" in data else None,
-    reason=parse_str(data["reason"]) if "reason" in data else None,
+    kind=parse_str(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    reason=parse_str(data["reason"]) if "reason" in data and data.get("reason") is not None else None,
   )
 
 def serialize_arm_position_update_canceled_event(data: ArmPositionUpdateCanceledEvent) -> object:
@@ -336,13 +336,13 @@ class CameraIntrinsics:
 
 def parse_camera_intrinsics(data: object):
   return CameraIntrinsics(
-    width=parse_f_64(data["width"]) if "width" in data else None,
-    height=parse_f_64(data["height"]) if "height" in data else None,
-    fx=parse_f_64(data["fx"]) if "fx" in data else None,
-    fy=parse_f_64(data["fy"]) if "fy" in data else None,
-    ppx=parse_f_64(data["ppx"]) if "ppx" in data else None,
-    ppy=parse_f_64(data["ppy"]) if "ppy" in data else None,
-    error=parse_i_8(data["error"]) if "error" in data else None,
+    width=parse_f_64(data["width"]) if "width" in data and data.get("width") is not None else None,
+    height=parse_f_64(data["height"]) if "height" in data and data.get("height") is not None else None,
+    fx=parse_f_64(data["fx"]) if "fx" in data and data.get("fx") is not None else None,
+    fy=parse_f_64(data["fy"]) if "fy" in data and data.get("fy") is not None else None,
+    ppx=parse_f_64(data["ppx"]) if "ppx" in data and data.get("ppx") is not None else None,
+    ppy=parse_f_64(data["ppy"]) if "ppy" in data and data.get("ppy") is not None else None,
+    error=parse_i_8(data["error"]) if "error" in data and data.get("error") is not None else None,
   )
 
 def serialize_camera_intrinsics(data: CameraIntrinsics) -> object:
@@ -456,13 +456,13 @@ class CameraSettings:
 
 def parse_camera_settings(data: object):
   return CameraSettings(
-    brightness=parse_i_16(data["brightness"]) if "brightness" in data else None,
-    contrast=parse_i_16(data["contrast"]) if "contrast" in data else None,
-    exposure=parse_i_16(data["exposure"]) if "exposure" in data else None,
-    sharpness=parse_i_16(data["sharpness"]) if "sharpness" in data else None,
-    hue=parse_i_16(data["hue"]) if "hue" in data else None,
-    whiteBalance=parse_i_16(data["whiteBalance"]) if "whiteBalance" in data else None,
-    autoWhiteBalance=parse_bool(data["autoWhiteBalance"]) if "autoWhiteBalance" in data else None,
+    brightness=parse_i_16(data["brightness"]) if "brightness" in data and data.get("brightness") is not None else None,
+    contrast=parse_i_16(data["contrast"]) if "contrast" in data and data.get("contrast") is not None else None,
+    exposure=parse_i_16(data["exposure"]) if "exposure" in data and data.get("exposure") is not None else None,
+    sharpness=parse_i_16(data["sharpness"]) if "sharpness" in data and data.get("sharpness") is not None else None,
+    hue=parse_i_16(data["hue"]) if "hue" in data and data.get("hue") is not None else None,
+    whiteBalance=parse_i_16(data["whiteBalance"]) if "whiteBalance" in data and data.get("whiteBalance") is not None else None,
+    autoWhiteBalance=parse_bool(data["autoWhiteBalance"]) if "autoWhiteBalance" in data and data.get("autoWhiteBalance") is not None else None,
   )
 
 def serialize_camera_settings(data: CameraSettings) -> object:
@@ -476,6 +476,127 @@ def serialize_camera_settings(data: CameraSettings) -> object:
     "autoWhiteBalance": None if data.autoWhiteBalance is None else serialize_bool(data.autoWhiteBalance),
   }
 
+@dataclass
+class CartesianPose:
+  """Cartesian pose
+"""
+  x: Union[float, None] = None
+  y: Union[float, None] = None
+  z: Union[float, None] = None
+  i: Union[float, None] = None
+  j: Union[float, None] = None
+  k: Union[float, None] = None
+  w: Union[float, None] = None
+
+  def validate_x(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "x is required for CartesianPose"]
+
+    if not isinstance(value, float):
+      return [False, "x must be of type float for CartesianPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_y(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "y is required for CartesianPose"]
+
+    if not isinstance(value, float):
+      return [False, "y must be of type float for CartesianPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_z(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "z is required for CartesianPose"]
+
+    if not isinstance(value, float):
+      return [False, "z must be of type float for CartesianPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_i(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "i is required for CartesianPose"]
+
+    if not isinstance(value, float):
+      return [False, "i must be of type float for CartesianPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_j(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "j is required for CartesianPose"]
+
+    if not isinstance(value, float):
+      return [False, "j must be of type float for CartesianPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_k(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "k is required for CartesianPose"]
+
+    if not isinstance(value, float):
+      return [False, "k must be of type float for CartesianPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_w(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "w is required for CartesianPose"]
+
+    if not isinstance(value, float):
+      return [False, "w must be of type float for CartesianPose, 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_x(self.x)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_y(self.y)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_z(self.z)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_i(self.i)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_j(self.j)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_k(self.k)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_w(self.w)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_cartesian_pose(data: object):
+  return CartesianPose(
+    x=parse_f_64(data["x"]) if "x" in data and data.get("x") is not None else None,
+    y=parse_f_64(data["y"]) if "y" in data and data.get("y") is not None else None,
+    z=parse_f_64(data["z"]) if "z" in data and data.get("z") is not None else None,
+    i=parse_f_64(data["i"]) if "i" in data and data.get("i") is not None else None,
+    j=parse_f_64(data["j"]) if "j" in data and data.get("j") is not None else None,
+    k=parse_f_64(data["k"]) if "k" in data and data.get("k") is not None else None,
+    w=parse_f_64(data["w"]) if "w" in data and data.get("w") is not None else None,
+  )
+
+def serialize_cartesian_pose(data: CartesianPose) -> object:
+  return {
+    "x": serialize_f_64(data.x),
+    "y": serialize_f_64(data.y),
+    "z": serialize_f_64(data.z),
+    "i": serialize_f_64(data.i),
+    "j": serialize_f_64(data.j),
+    "k": serialize_f_64(data.k),
+    "w": serialize_f_64(data.w),
+  }
+
 class ConnectionStatus(Enum):
   Connected = "connected"
   """Enum Connected = `connected`"""
@@ -539,9 +660,9 @@ class DHAGGripperCommandRequest:
 
 def parse_dhag_gripper_command_request(data: object):
   return DHAGGripperCommandRequest(
-    target_diameter=parse_f_64(data["target_diameter"]) if "target_diameter" in data else None,
-    target_force=parse_f_64(data["target_force"]) if "target_force" in data else None,
-    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data else None,
+    target_diameter=parse_f_64(data["target_diameter"]) if "target_diameter" in data and data.get("target_diameter") is not None else None,
+    target_force=parse_f_64(data["target_force"]) if "target_force" in data and data.get("target_force") is not None else None,
+    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data and data.get("target_speed") is not None else None,
   )
 
 def serialize_dhag_gripper_command_request(data: DHAGGripperCommandRequest) -> object:
@@ -573,7 +694,7 @@ class DHAGGripperConfiguration:
 
 def parse_dhag_gripper_configuration(data: object):
   return DHAGGripperConfiguration(
-    diameter=parse_f_64(data["diameter"]) if "diameter" in data else None,
+    diameter=parse_f_64(data["diameter"]) if "diameter" in data and data.get("diameter") is not None else None,
   )
 
 def serialize_dhag_gripper_configuration(data: DHAGGripperConfiguration) -> object:
@@ -630,9 +751,9 @@ class DHCGIGripperCommandRequest:
 
 def parse_dhcgi_gripper_command_request(data: object):
   return DHCGIGripperCommandRequest(
-    target_diameter=parse_f_64(data["target_diameter"]) if "target_diameter" in data else None,
-    target_force=parse_f_64(data["target_force"]) if "target_force" in data else None,
-    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data else None,
+    target_diameter=parse_f_64(data["target_diameter"]) if "target_diameter" in data and data.get("target_diameter") is not None else None,
+    target_force=parse_f_64(data["target_force"]) if "target_force" in data and data.get("target_force") is not None else None,
+    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data and data.get("target_speed") is not None else None,
   )
 
 def serialize_dhcgi_gripper_command_request(data: DHCGIGripperCommandRequest) -> object:
@@ -664,7 +785,7 @@ class DHCGIGripperConfiguration:
 
 def parse_dhcgi_gripper_configuration(data: object):
   return DHCGIGripperConfiguration(
-    diameter=parse_f_64(data["diameter"]) if "diameter" in data else None,
+    diameter=parse_f_64(data["diameter"]) if "diameter" in data and data.get("diameter") is not None else None,
   )
 
 def serialize_dhcgi_gripper_configuration(data: DHCGIGripperConfiguration) -> object:
@@ -721,9 +842,9 @@ class DHPGCGripperCommandRequest:
 
 def parse_dhpgc_gripper_command_request(data: object):
   return DHPGCGripperCommandRequest(
-    target_diameter=parse_f_64(data["target_diameter"]) if "target_diameter" in data else None,
-    target_force=parse_f_64(data["target_force"]) if "target_force" in data else None,
-    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data else None,
+    target_diameter=parse_f_64(data["target_diameter"]) if "target_diameter" in data and data.get("target_diameter") is not None else None,
+    target_force=parse_f_64(data["target_force"]) if "target_force" in data and data.get("target_force") is not None else None,
+    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data and data.get("target_speed") is not None else None,
   )
 
 def serialize_dhpgc_gripper_command_request(data: DHPGCGripperCommandRequest) -> object:
@@ -755,7 +876,7 @@ class DHPGCGripperConfiguration:
 
 def parse_dhpgc_gripper_configuration(data: object):
   return DHPGCGripperConfiguration(
-    diameter=parse_f_64(data["diameter"]) if "diameter" in data else None,
+    diameter=parse_f_64(data["diameter"]) if "diameter" in data and data.get("diameter") is not None else None,
   )
 
 def serialize_dhpgc_gripper_configuration(data: DHPGCGripperConfiguration) -> object:
@@ -786,7 +907,7 @@ class EngageEmergencyStopRequest:
 
 def parse_engage_emergency_stop_request(data: object):
   return EngageEmergencyStopRequest(
-    reason=parse_str(data["reason"]) if "reason" in data else None,
+    reason=parse_str(data["reason"]) if "reason" in data and data.get("reason") is not None else None,
   )
 
 def serialize_engage_emergency_stop_request(data: EngageEmergencyStopRequest) -> object:
@@ -842,9 +963,9 @@ class EnvironmentVariable:
 
 def parse_environment_variable(data: object):
   return EnvironmentVariable(
-    id=parse_str(data["id"]) if "id" in data else None,
-    name=parse_str(data["name"]) if "name" in data else None,
-    value=parse_str(data["value"]) if "value" in data else None,
+    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,
+    value=parse_str(data["value"]) if "value" in data and data.get("value") is not None else None,
   )
 
 def serialize_environment_variable(data: EnvironmentVariable) -> object:
@@ -898,6 +1019,112 @@ def parse_error_enum(data: object) -> ErrorEnum:
 def serialize_error_enum(data: Union[ErrorEnum, str]) -> object:
   return ErrorEnum(data).value
 
+@dataclass
+class EulerPose:
+  """Euler pose
+"""
+  x: Union[float, None] = None
+  y: Union[float, None] = None
+  z: Union[float, None] = None
+  rx: Union[float, None] = None
+  ry: Union[float, None] = None
+  rz: Union[float, None] = None
+
+  def validate_x(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "x must be of type float for EulerPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_y(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "y must be of type float for EulerPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_z(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "z must be of type float for EulerPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_rx(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "rx must be of type float for EulerPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_ry(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "ry must be of type float for EulerPose, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_rz(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "rz must be of type float for EulerPose, 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_x(self.x)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_y(self.y)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_z(self.z)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_rx(self.rx)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_ry(self.ry)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_rz(self.rz)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_euler_pose(data: object):
+  return EulerPose(
+    x=parse_f_64(data["x"]) if "x" in data and data.get("x") is not None else None,
+    y=parse_f_64(data["y"]) if "y" in data and data.get("y") is not None else None,
+    z=parse_f_64(data["z"]) if "z" in data and data.get("z") is not None else None,
+    rx=parse_f_64(data["rx"]) if "rx" in data and data.get("rx") is not None else None,
+    ry=parse_f_64(data["ry"]) if "ry" in data and data.get("ry") is not None else None,
+    rz=parse_f_64(data["rz"]) if "rz" in data and data.get("rz") is not None else None,
+  )
+
+def serialize_euler_pose(data: EulerPose) -> object:
+  return {
+    "x": None if data.x is None else serialize_f_64(data.x),
+    "y": None if data.y is None else serialize_f_64(data.y),
+    "z": None if data.z is None else serialize_f_64(data.z),
+    "rx": None if data.rx is None else serialize_f_64(data.rx),
+    "ry": None if data.ry is None else serialize_f_64(data.ry),
+    "rz": None if data.rz is None else serialize_f_64(data.rz),
+  }
+
 class ForceUnitKind(Enum):
   Newtons = "newtons"
   """Enum Newtons = `newtons`"""
@@ -917,8 +1144,6 @@ class GripperKindEnum(Enum):
   """An OnRobot 2FG14 Gripper is connected"""
   Onrobot3Fg15 = "onrobot_3fg15"
   """An OnRobot 3FG15 Gripper is connected"""
-  OnrobotScrewdriver = "onrobot_screwdriver"
-  """An OnRobot Screwdriver is connected"""
   DhAg = "dh_ag"
   """A DH AG Gripper is connected"""
   DhPgc = "dh_pgc"
@@ -948,6 +1173,120 @@ def serialize_io_state_map(data: IOStateMap) -> object:
     serialize_str(key): serialize_str(value) for key, value in data.items()
   }
 
+@dataclass
+class JointAngles:
+  """Joint angles
+"""
+  j0: Union[float, None] = None
+  j1: Union[float, None] = None
+  j2: Union[float, None] = None
+  j3: Union[float, None] = None
+  j4: Union[float, None] = None
+  j5: Union[float, None] = None
+
+  def validate_j0(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "j0 must be of type float for JointAngles, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_j1(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "j1 must be of type float for JointAngles, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_j2(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "j2 must be of type float for JointAngles, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_j3(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "j3 must be of type float for JointAngles, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_j4(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "j4 must be of type float for JointAngles, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_j5(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "j5 must be of type float for JointAngles, 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_j0(self.j0)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_j1(self.j1)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_j2(self.j2)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_j3(self.j3)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_j4(self.j4)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_j5(self.j5)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_joint_angles(data: object):
+  return JointAngles(
+    j0=parse_f_64(data["j0"]) if "j0" in data and data.get("j0") is not None else None,
+    j1=parse_f_64(data["j1"]) if "j1" in data and data.get("j1") is not None else None,
+    j2=parse_f_64(data["j2"]) if "j2" in data and data.get("j2") is not None else None,
+    j3=parse_f_64(data["j3"]) if "j3" in data and data.get("j3") is not None else None,
+    j4=parse_f_64(data["j4"]) if "j4" in data and data.get("j4") is not None else None,
+    j5=parse_f_64(data["j5"]) if "j5" in data and data.get("j5") is not None else None,
+  )
+
+def serialize_joint_angles(data: JointAngles) -> object:
+  return {
+    "j0": None if data.j0 is None else serialize_f_64(data.j0),
+    "j1": None if data.j1 is None else serialize_f_64(data.j1),
+    "j2": None if data.j2 is None else serialize_f_64(data.j2),
+    "j3": None if data.j3 is None else serialize_f_64(data.j3),
+    "j4": None if data.j4 is None else serialize_f_64(data.j4),
+    "j5": None if data.j5 is None else serialize_f_64(data.j5),
+  }
+
+JointAnglesArray = List[float]
+
+def parse_joint_angles_array(data: object) -> JointAnglesArray:
+  return [parse_f_64(item) for item in data]
+
+def serialize_joint_angles_array(data: JointAnglesArray) -> List[object]:
+  return [serialize_f_64(item) for item in data]
+
 JointRotations = Tuple[float,float,float,float,float,float,]
 
 def parse_joint_rotations(data: object) -> JointRotations:
@@ -986,6 +1325,34 @@ def parse_linear_unit_kind(data: object) -> LinearUnitKind:
 def serialize_linear_unit_kind(data: Union[LinearUnitKind, str]) -> object:
   return LinearUnitKind(data).value
 
+MaxJointAcclerations = Tuple[float,float,float,float,float,float,]
+
+def parse_max_joint_acclerations(data: object) -> MaxJointAcclerations:
+  return (parse_f_64(data[0]),parse_f_64(data[1]),parse_f_64(data[2]),parse_f_64(data[3]),parse_f_64(data[4]),parse_f_64(data[5]),)
+
+def serialize_max_joint_acclerations(data: MaxJointAcclerations) -> object:
+  return [serialize_f_64(data[0]),serialize_f_64(data[1]),serialize_f_64(data[2]),serialize_f_64(data[3]),serialize_f_64(data[4]),serialize_f_64(data[5]),]
+
+MaxJointSpeeds = Tuple[float,float,float,float,float,float,]
+
+def parse_max_joint_speeds(data: object) -> MaxJointSpeeds:
+  return (parse_f_64(data[0]),parse_f_64(data[1]),parse_f_64(data[2]),parse_f_64(data[3]),parse_f_64(data[4]),parse_f_64(data[5]),)
+
+def serialize_max_joint_speeds(data: MaxJointSpeeds) -> object:
+  return [serialize_f_64(data[0]),serialize_f_64(data[1]),serialize_f_64(data[2]),serialize_f_64(data[3]),serialize_f_64(data[4]),serialize_f_64(data[5]),]
+
+class MovementKindEnum(Enum):
+  Joint = "joint"
+  """Enum Joint = `joint`"""
+  Line = "line"
+  """Enum Line = `line`"""
+
+def parse_movement_kind_enum(data: object) -> MovementKindEnum:
+  return MovementKindEnum(data)
+
+def serialize_movement_kind_enum(data: Union[MovementKindEnum, str]) -> object:
+  return MovementKindEnum(data).value
+
 class OnRobot2FG14ControlKindEnum(Enum):
   Move = "move"
   """Move gripper to target grip width"""
@@ -1024,326 +1391,270 @@ def parse_on_robot_3_fg_15_control_kind_enum(data: object) -> OnRobot3FG15Contro
 def serialize_on_robot_3_fg_15_control_kind_enum(data: Union[OnRobot3FG15ControlKindEnum, str]) -> object:
   return OnRobot3FG15ControlKindEnum(data).value
 
-class OnRobotGripKindEnum(Enum):
-  Inward = "inward"
-  """Enum Inward = `inward`"""
-  Outward = "outward"
-  """Enum Outward = `outward`"""
+class OrientationKindEnum(Enum):
+  Quaternion = "quaternion"
+  """Enum Quaternion = `quaternion`"""
 
-def parse_on_robot_grip_kind_enum(data: object) -> OnRobotGripKindEnum:
-  return OnRobotGripKindEnum(data)
+def parse_orientation_kind_enum(data: object) -> OrientationKindEnum:
+  return OrientationKindEnum(data)
 
-def serialize_on_robot_grip_kind_enum(data: Union[OnRobotGripKindEnum, str]) -> object:
-  return OnRobotGripKindEnum(data).value
+def serialize_orientation_kind_enum(data: Union[OrientationKindEnum, str]) -> object:
+  return OrientationKindEnum(data).value
 
 @dataclass
-class OnRobotScrewdriverConfiguration:
-  """Configuration for OnRobot Screwdriver"""
-  status: Union[int, None] = None
-  error: Union[str, None] = None
-  busy: Union[bool, None] = None
-  additional_results: Union[int, None] = None
-  current_torque: Union[float, None] = None
-  shank_position: Union[float, None] = None
-  torque_angle_gradient: Union[float, None] = None
-  achieved_torque: Union[float, None] = None
-  target_force: Union[float, None] = None
-  target_torque: Union[float, None] = None
-  quick_changer_version: Union[int, None] = None
-  uncalibrated_error: Union[bool, None] = None
+class Pagination:
+  """Common Pagination Metadata"""
+  total: Union[int, None] = None
+  limit: Union[int, None] = None
+  offset: Union[int, None] = None
 
-  def validate_status(self, value: int) -> Tuple[bool, str]:
+  def validate_total(self, value: int) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, int):
-      return [False, "status must be of type int for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+      return [False, "total must be of type int for Pagination, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_error(self, value: str) -> Tuple[bool, str]:
+  def validate_limit(self, value: int) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, str):
-      return [False, "error must be of type str for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+    if not isinstance(value, int):
+      return [False, "limit must be of type int for Pagination, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_busy(self, value: bool) -> Tuple[bool, str]:
+  def validate_offset(self, value: int) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "busy must be of type bool for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+    if not isinstance(value, int):
+      return [False, "offset must be of type int for Pagination, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_additional_results(self, value: int) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_total(self.total)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_limit(self.limit)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_offset(self.offset)
+    if not is_valid:
+      raise TypeError(error_str)
 
-    if not isinstance(value, int):
-      return [False, "additional_results must be of type int for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+def parse_pagination(data: object):
+  return Pagination(
+    total=parse_i_64(data["total"]) if "total" in data and data.get("total") is not None else None,
+    limit=parse_i_64(data["limit"]) if "limit" in data and data.get("limit") is not None else None,
+    offset=parse_i_64(data["offset"]) if "offset" in data and data.get("offset") is not None else None,
+  )
 
-    return [True, ""]
+def serialize_pagination(data: Pagination) -> object:
+  return {
+    "total": None if data.total is None else serialize_i_64(data.total),
+    "limit": None if data.limit is None else serialize_i_64(data.limit),
+    "offset": None if data.offset is None else serialize_i_64(data.offset),
+  }
+
+@dataclass
+class Plane:
+  """Plane in 3D space"""
+  id: Union[str, None] = None
+  name: Union[str, None] = None
 
-  def validate_current_torque(self, value: float) -> Tuple[bool, str]:
+  def validate_id(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "current_torque must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "id must be of type str for Plane, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_shank_position(self, value: float) -> Tuple[bool, str]:
+  def validate_name(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "shank_position must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "name must be of type str for Plane, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_torque_angle_gradient(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      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)
 
-    if not isinstance(value, float):
-      return [False, "torque_angle_gradient must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+def parse_plane(data: object):
+  return Plane(
+    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,
+  )
 
-    return [True, ""]
+def serialize_plane(data: Plane) -> 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),
+  }
 
-  def validate_achieved_torque(self, value: float) -> Tuple[bool, str]:
+@dataclass
+class PoseDistanceResponse:
+  """Response: Distance between two cartesian poses
+"""
+  distance: Union[float, None] = None
+
+  def validate_distance(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "achieved_torque must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+      return [False, "distance must be of type float for PoseDistanceResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_target_force(self, value: float) -> Tuple[bool, str]:
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_distance(self.distance)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_pose_distance_response(data: object):
+  return PoseDistanceResponse(
+    distance=parse_f_64(data["distance"]) if "distance" in data and data.get("distance") is not None else None,
+  )
+
+def serialize_pose_distance_response(data: PoseDistanceResponse) -> object:
+  return {
+    "distance": None if data.distance is None else serialize_f_64(data.distance),
+  }
+
+@dataclass
+class PositionPose:
+  """The full 3D position with rotation"""
+  x: Union[float, None] = None
+  y: Union[float, None] = None
+  z: Union[float, None] = None
+  w: Union[float, None] = None
+  i: Union[float, None] = None
+  j: Union[float, None] = None
+  k: Union[float, None] = None
+
+  def validate_x(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "target_force must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+      return [False, "x must be of type float for PositionPose, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_target_torque(self, value: float) -> Tuple[bool, str]:
+  def validate_y(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "target_torque must be of type float for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+      return [False, "y must be of type float for PositionPose, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_quick_changer_version(self, value: int) -> Tuple[bool, str]:
+  def validate_z(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, int):
-      return [False, "quick_changer_version must be of type int for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "z must be of type float for PositionPose, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_uncalibrated_error(self, value: bool) -> Tuple[bool, str]:
+  def validate_w(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "uncalibrated_error must be of type bool for OnRobotScrewdriverConfiguration, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "w must be of type float for PositionPose, got " + type(value).__name__]
 
     return [True, ""]
 
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_status(self.status)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_error(self.error)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_busy(self.busy)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_additional_results(self.additional_results)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_current_torque(self.current_torque)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_shank_position(self.shank_position)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_torque_angle_gradient(self.torque_angle_gradient)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_achieved_torque(self.achieved_torque)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_target_force(self.target_force)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_target_torque(self.target_torque)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_quick_changer_version(self.quick_changer_version)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_uncalibrated_error(self.uncalibrated_error)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_on_robot_screwdriver_configuration(data: object):
-  return OnRobotScrewdriverConfiguration(
-    status=parse_i_32(data["status"]) if "status" in data else None,
-    error=parse_str(data["error"]) if "error" in data else None,
-    busy=parse_bool(data["busy"]) if "busy" in data else None,
-    additional_results=parse_i_32(data["additional_results"]) if "additional_results" in data else None,
-    current_torque=parse_f_64(data["current_torque"]) if "current_torque" in data else None,
-    shank_position=parse_f_64(data["shank_position"]) if "shank_position" in data else None,
-    torque_angle_gradient=parse_f_64(data["torque_angle_gradient"]) if "torque_angle_gradient" in data else None,
-    achieved_torque=parse_f_64(data["achieved_torque"]) if "achieved_torque" in data else None,
-    target_force=parse_f_64(data["target_force"]) if "target_force" in data else None,
-    target_torque=parse_f_64(data["target_torque"]) if "target_torque" in data else None,
-    quick_changer_version=parse_i_32(data["quick_changer_version"]) if "quick_changer_version" in data else None,
-    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data else None,
-  )
-
-def serialize_on_robot_screwdriver_configuration(data: OnRobotScrewdriverConfiguration) -> object:
-  return {
-    "status": None if data.status is None else serialize_i_32(data.status),
-    "error": None if data.error is None else serialize_str(data.error),
-    "busy": None if data.busy is None else serialize_bool(data.busy),
-    "additional_results": None if data.additional_results is None else serialize_i_32(data.additional_results),
-    "current_torque": None if data.current_torque is None else serialize_f_64(data.current_torque),
-    "shank_position": None if data.shank_position is None else serialize_f_64(data.shank_position),
-    "torque_angle_gradient": None if data.torque_angle_gradient is None else serialize_f_64(data.torque_angle_gradient),
-    "achieved_torque": None if data.achieved_torque is None else serialize_f_64(data.achieved_torque),
-    "target_force": None if data.target_force is None else serialize_f_64(data.target_force),
-    "target_torque": None if data.target_torque is None else serialize_f_64(data.target_torque),
-    "quick_changer_version": None if data.quick_changer_version is None else serialize_i_32(data.quick_changer_version),
-    "uncalibrated_error": None if data.uncalibrated_error is None else serialize_bool(data.uncalibrated_error),
-  }
-
-class OrientationKindEnum(Enum):
-  Quaternion = "quaternion"
-  """Enum Quaternion = `quaternion`"""
-
-def parse_orientation_kind_enum(data: object) -> OrientationKindEnum:
-  return OrientationKindEnum(data)
-
-def serialize_orientation_kind_enum(data: Union[OrientationKindEnum, str]) -> object:
-  return OrientationKindEnum(data).value
-
-@dataclass
-class Pagination:
-  """Common Pagination Metadata"""
-  total: Union[int, None] = None
-  limit: Union[int, None] = None
-  offset: Union[int, None] = None
-
-  def validate_total(self, value: int) -> Tuple[bool, str]:
+  def validate_i(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, int):
-      return [False, "total must be of type int for Pagination, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "i must be of type float for PositionPose, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_limit(self, value: int) -> Tuple[bool, str]:
+  def validate_j(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, int):
-      return [False, "limit must be of type int for Pagination, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "j must be of type float for PositionPose, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_offset(self, value: int) -> Tuple[bool, str]:
+  def validate_k(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, int):
-      return [False, "offset must be of type int for Pagination, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "k must be of type float for PositionPose, 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_total(self.total)
+    is_valid, error_str = self.validate_x(self.x)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_limit(self.limit)
+    is_valid, error_str = self.validate_y(self.y)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_offset(self.offset)
+    is_valid, error_str = self.validate_z(self.z)
     if not is_valid:
       raise TypeError(error_str)
-
-def parse_pagination(data: object):
-  return Pagination(
-    total=parse_i_64(data["total"]) if "total" in data else None,
-    limit=parse_i_64(data["limit"]) if "limit" in data else None,
-    offset=parse_i_64(data["offset"]) if "offset" in data else None,
-  )
-
-def serialize_pagination(data: Pagination) -> object:
-  return {
-    "total": None if data.total is None else serialize_i_64(data.total),
-    "limit": None if data.limit is None else serialize_i_64(data.limit),
-    "offset": None if data.offset is None else serialize_i_64(data.offset),
-  }
-
-@dataclass
-class Plane:
-  """Plane in 3D space"""
-  id: Union[str, None] = None
-  name: 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 Plane, 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 Plane, 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)
+    is_valid, error_str = self.validate_w(self.w)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_name(self.name)
+    is_valid, error_str = self.validate_i(self.i)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_j(self.j)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_k(self.k)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_plane(data: object):
-  return Plane(
-    id=parse_str(data["id"]) if "id" in data else None,
-    name=parse_str(data["name"]) if "name" in data else None,
+def parse_position_pose(data: object):
+  return PositionPose(
+    x=parse_f_64(data["x"]) if "x" in data and data.get("x") is not None else None,
+    y=parse_f_64(data["y"]) if "y" in data and data.get("y") is not None else None,
+    z=parse_f_64(data["z"]) if "z" in data and data.get("z") is not None else None,
+    w=parse_f_64(data["w"]) if "w" in data and data.get("w") is not None else None,
+    i=parse_f_64(data["i"]) if "i" in data and data.get("i") is not None else None,
+    j=parse_f_64(data["j"]) if "j" in data and data.get("j") is not None else None,
+    k=parse_f_64(data["k"]) if "k" in data and data.get("k") is not None else None,
   )
 
-def serialize_plane(data: Plane) -> object:
+def serialize_position_pose(data: PositionPose) -> 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),
+    "x": None if data.x is None else serialize_f_64(data.x),
+    "y": None if data.y is None else serialize_f_64(data.y),
+    "z": None if data.z is None else serialize_f_64(data.z),
+    "w": None if data.w is None else serialize_f_64(data.w),
+    "i": None if data.i is None else serialize_f_64(data.i),
+    "j": None if data.j is None else serialize_f_64(data.j),
+    "k": None if data.k is None else serialize_f_64(data.k),
   }
 
 @dataclass
@@ -1407,10 +1718,10 @@ class Quaternion:
 
 def parse_quaternion(data: object):
   return Quaternion(
-    x=parse_f_64(data["x"]) if "x" in data else None,
-    y=parse_f_64(data["y"]) if "y" in data else None,
-    z=parse_f_64(data["z"]) if "z" in data else None,
-    w=parse_f_64(data["w"]) if "w" in data else None,
+    x=parse_f_64(data["x"]) if "x" in data and data.get("x") is not None else None,
+    y=parse_f_64(data["y"]) if "y" in data and data.get("y") is not None else None,
+    z=parse_f_64(data["z"]) if "z" in data and data.get("z") is not None else None,
+    w=parse_f_64(data["w"]) if "w" in data and data.get("w") is not None else None,
   )
 
 def serialize_quaternion(data: Quaternion) -> object:
@@ -1421,6 +1732,70 @@ def serialize_quaternion(data: Quaternion) -> object:
     "w": None if data.w is None else serialize_f_64(data.w),
   }
 
+class RecoveryStateEnum(Enum):
+  Success = "Success"
+  """Enum Success = `Success`"""
+  Interrupted = "Interrupted"
+  """Enum Interrupted = `Interrupted`"""
+  NonIdle = "NonIdle"
+  """Enum NonIdle = `NonIdle`"""
+  Braked = "Braked"
+  """Enum Braked = `Braked`"""
+  PlanningFailure = "PlanningFailure"
+  """Enum PlanningFailure = `PlanningFailure`"""
+  ExecutionFailure = "ExecutionFailure"
+  """Enum ExecutionFailure = `ExecutionFailure`"""
+  ControlSystemFailure = "ControlSystemFailure"
+  """Enum ControlSystemFailure = `ControlSystemFailure`"""
+  EStopTriggered = "EStopTriggered"
+  """Enum EStopTriggered = `EStopTriggered`"""
+  GripperFailure = "GripperFailure"
+  """Enum GripperFailure = `GripperFailure`"""
+  OutOfJointLimitsFailure = "OutOfJointLimitsFailure"
+  """Enum OutOfJointLimitsFailure = `OutOfJointLimitsFailure`"""
+  CollisionFailure = "CollisionFailure"
+  """Enum CollisionFailure = `CollisionFailure`"""
+  TorqueCollisionFailure = "TorqueCollisionFailure"
+  """Enum TorqueCollisionFailure = `TorqueCollisionFailure`"""
+  InBoxingPositionFailure = "InBoxingPositionFailure"
+  """Enum InBoxingPositionFailure = `InBoxingPositionFailure`"""
+  PowerBoardCheckFailure = "PowerBoardCheckFailure"
+  """Enum PowerBoardCheckFailure = `PowerBoardCheckFailure`"""
+  MotionPlannerFailure = "MotionPlannerFailure"
+  """Enum MotionPlannerFailure = `MotionPlannerFailure`"""
+  MotionPlannerFailureStartPositionCollision = "MotionPlannerFailureStartPositionCollision"
+  """Enum MotionPlannerFailureStartPositionCollision = `MotionPlannerFailureStartPositionCollision`"""
+  IOFailure = "IOFailure"
+  """Enum IOFailure = `IOFailure`"""
+  InvalidRoutineLoadedFailure = "InvalidRoutineLoadedFailure"
+  """Enum InvalidRoutineLoadedFailure = `InvalidRoutineLoadedFailure`"""
+  InferenceFailure = "InferenceFailure"
+  """Enum InferenceFailure = `InferenceFailure`"""
+  CameraFailure = "CameraFailure"
+  """Enum CameraFailure = `CameraFailure`"""
+  HaasFailure = "HaasFailure"
+  """Enum HaasFailure = `HaasFailure`"""
+  BotmanHeartbeatLost = "BotmanHeartbeatLost"
+  """Enum BotmanHeartbeatLost = `BotmanHeartbeatLost`"""
+  InternalFailure = "InternalFailure"
+  """Enum InternalFailure = `InternalFailure`"""
+  TorqueLimitExceeded = "TorqueLimitExceeded"
+  """Enum TorqueLimitExceeded = `TorqueLimitExceeded`"""
+  StepPlayFailure = "StepPlayFailure"
+  """Enum StepPlayFailure = `StepPlayFailure`"""
+  UnbrakeFailure = "UnbrakeFailure"
+  """Enum UnbrakeFailure = `UnbrakeFailure`"""
+  WeldFailure = "WeldFailure"
+  """Enum WeldFailure = `WeldFailure`"""
+  TriggerFaultFailure = "TriggerFaultFailure"
+  """Enum TriggerFaultFailure = `TriggerFaultFailure`"""
+
+def parse_recovery_state_enum(data: object) -> RecoveryStateEnum:
+  return RecoveryStateEnum(data)
+
+def serialize_recovery_state_enum(data: Union[RecoveryStateEnum, str]) -> object:
+  return RecoveryStateEnum(data).value
+
 class RecoveryTypeEnum(Enum):
   Recoverable = "Recoverable"
   """Enum Recoverable = `Recoverable`"""
@@ -1451,28 +1826,6 @@ def parse_robot_control_mode_enum(data: object) -> RobotControlModeEnum:
 def serialize_robot_control_mode_enum(data: Union[RobotControlModeEnum, str]) -> object:
   return RobotControlModeEnum(data).value
 
-class RobotStatusEnum(Enum):
-  Idle = "Idle"
-  """Enum Idle = `Idle`"""
-  RunningAdHocCommand = "RunningAdHocCommand"
-  """Enum RunningAdHocCommand = `RunningAdHocCommand`"""
-  RoutineRunning = "RoutineRunning"
-  """Enum RoutineRunning = `RoutineRunning`"""
-  Antigravity = "Antigravity"
-  """Enum Antigravity = `Antigravity`"""
-  AntigravitySlow = "AntigravitySlow"
-  """Enum AntigravitySlow = `AntigravitySlow`"""
-  Failure = "Failure"
-  """Enum Failure = `Failure`"""
-  Recovering = "Recovering"
-  """Enum Recovering = `Recovering`"""
-
-def parse_robot_status_enum(data: object) -> RobotStatusEnum:
-  return RobotStatusEnum(data)
-
-def serialize_robot_status_enum(data: Union[RobotStatusEnum, str]) -> object:
-  return RobotStatusEnum(data).value
-
 class ROSControlStateEnum(Enum):
   Enabled = "enabled"
   """ROS control is enabled."""
@@ -1485,51 +1838,210 @@ def parse_ros_control_state_enum(data: object) -> ROSControlStateEnum:
 def serialize_ros_control_state_enum(data: Union[ROSControlStateEnum, str]) -> object:
   return ROSControlStateEnum(data).value
 
-RoutineVariablesStateMap = Dict[str, str]
+@dataclass
+class RoutineStateResponse:
+  """State of the routine."""
+  is_paused: Union[bool, None] = None
+  current_step_id: Union[str, None] = None
+  start_time: Union[str, None] = None
+  run_time_seconds: Union[float, None] = None
+  cycle_count: Union[int, None] = None
+  total_expected_cycles: Union[int, None] = None
+  should_next_arm_move_be_guided_mode: Union[bool, None] = None
+  is_preflight_test_run: Union[bool, None] = None
 
-def parse_routine_variables_state_map(data: object) -> RoutineVariablesStateMap:
-  return {
-    parse_str(key): parse_str(value) for key, value in data.items()
-  }
+  def validate_is_paused(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "is_paused is required for RoutineStateResponse"]
 
-def serialize_routine_variables_state_map(data: RoutineVariablesStateMap) -> object:
-  return {
-    serialize_str(key): serialize_str(value) for key, value in data.items()
-  }
+    if not isinstance(value, bool):
+      return [False, "is_paused must be of type bool for RoutineStateResponse, got " + type(value).__name__]
 
-@dataclass
-class RuntimeVariable:
-  """Runtime Variable state"""
-  value: Union[str, None] = None
+    return [True, ""]
 
-  def validate_value(self, value: str) -> Tuple[bool, str]:
+  def validate_current_step_id(self, value: str) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "current_step_id is required for RoutineStateResponse"]
 
     if not isinstance(value, str):
-      return [False, "value must be of type str for RuntimeVariable, got " + type(value).__name__]
+      return [False, "current_step_id must be of type str for RoutineStateResponse, 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_value(self.value)
-    if not is_valid:
-      raise TypeError(error_str)
+  def validate_start_time(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "start_time is required for RoutineStateResponse"]
 
-def parse_runtime_variable(data: object):
-  return RuntimeVariable(
-    value=parse_str(data["value"]) if "value" in data else None,
-  )
+    if not isinstance(value, str):
+      return [False, "start_time must be of type str for RoutineStateResponse, got " + type(value).__name__]
 
-def serialize_runtime_variable(data: RuntimeVariable) -> object:
-  return {
-    "value": None if data.value is None else serialize_str(data.value),
-  }
+    return [True, ""]
 
-class SchunkEGxControlKindEnum(Enum):
-  Move = "move"
-  """Move gripper to target grip diameter"""
+  def validate_run_time_seconds(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "run_time_seconds is required for RoutineStateResponse"]
+
+    if not isinstance(value, float):
+      return [False, "run_time_seconds must be of type float for RoutineStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_cycle_count(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "cycle_count must be of type int for RoutineStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_total_expected_cycles(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "total_expected_cycles must be of type int for RoutineStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_should_next_arm_move_be_guided_mode(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "should_next_arm_move_be_guided_mode must be of type bool for RoutineStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_is_preflight_test_run(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "is_preflight_test_run is required for RoutineStateResponse"]
+
+    if not isinstance(value, bool):
+      return [False, "is_preflight_test_run must be of type bool for RoutineStateResponse, 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_is_paused(self.is_paused)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_current_step_id(self.current_step_id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_start_time(self.start_time)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_run_time_seconds(self.run_time_seconds)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_cycle_count(self.cycle_count)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_total_expected_cycles(self.total_expected_cycles)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_should_next_arm_move_be_guided_mode(self.should_next_arm_move_be_guided_mode)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_is_preflight_test_run(self.is_preflight_test_run)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_routine_state_response(data: object):
+  return RoutineStateResponse(
+    is_paused=parse_bool(data["is_paused"]) if "is_paused" in data and data.get("is_paused") is not None else None,
+    current_step_id=parse_str(data["current_step_id"]) if "current_step_id" in data and data.get("current_step_id") is not None else None,
+    start_time=parse_str(data["start_time"]) if "start_time" in data and data.get("start_time") is not None else None,
+    run_time_seconds=parse_f_64(data["run_time_seconds"]) if "run_time_seconds" in data and data.get("run_time_seconds") is not None else None,
+    cycle_count=parse_i_64(data["cycle_count"]) if "cycle_count" in data and data.get("cycle_count") is not None else None,
+    total_expected_cycles=parse_i_64(data["total_expected_cycles"]) if "total_expected_cycles" in data and data.get("total_expected_cycles") is not None else None,
+    should_next_arm_move_be_guided_mode=parse_bool(data["should_next_arm_move_be_guided_mode"]) if "should_next_arm_move_be_guided_mode" in data and data.get("should_next_arm_move_be_guided_mode") is not None else None,
+    is_preflight_test_run=parse_bool(data["is_preflight_test_run"]) if "is_preflight_test_run" in data and data.get("is_preflight_test_run") is not None else None,
+  )
+
+def serialize_routine_state_response(data: RoutineStateResponse) -> object:
+  return {
+    "is_paused": serialize_bool(data.is_paused),
+    "current_step_id": serialize_str(data.current_step_id),
+    "start_time": serialize_str(data.start_time),
+    "run_time_seconds": serialize_f_64(data.run_time_seconds),
+    "cycle_count": None if data.cycle_count is None else serialize_i_64(data.cycle_count),
+    "total_expected_cycles": None if data.total_expected_cycles is None else serialize_i_64(data.total_expected_cycles),
+    "should_next_arm_move_be_guided_mode": None if data.should_next_arm_move_be_guided_mode is None else serialize_bool(data.should_next_arm_move_be_guided_mode),
+    "is_preflight_test_run": serialize_bool(data.is_preflight_test_run),
+  }
+
+RoutineStepVariablesData = Dict[str, str]
+
+def parse_routine_step_variables_data(data: object) -> RoutineStepVariablesData:
+  return {
+    parse_str(key): parse_str(value) for key, value in data.items()
+  }
+
+def serialize_routine_step_variables_data(data: RoutineStepVariablesData) -> object:
+  return {
+    serialize_str(key): serialize_str(value) for key, value in data.items()
+  }
+
+RoutineStepVariablesIdMap = Dict[str, str]
+
+def parse_routine_step_variables_id_map(data: object) -> RoutineStepVariablesIdMap:
+  return {
+    parse_str(key): parse_str(value) for key, value in data.items()
+  }
+
+def serialize_routine_step_variables_id_map(data: RoutineStepVariablesIdMap) -> object:
+  return {
+    serialize_str(key): serialize_str(value) for key, value in data.items()
+  }
+
+RoutineVariablesStateMap = Dict[str, str]
+
+def parse_routine_variables_state_map(data: object) -> RoutineVariablesStateMap:
+  return {
+    parse_str(key): parse_str(value) for key, value in data.items()
+  }
+
+def serialize_routine_variables_state_map(data: RoutineVariablesStateMap) -> object:
+  return {
+    serialize_str(key): serialize_str(value) for key, value in data.items()
+  }
+
+@dataclass
+class RuntimeVariable:
+  """Runtime Variable state"""
+  value: Union[str, None] = None
+
+  def validate_value(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "value must be of type str for RuntimeVariable, 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_value(self.value)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_runtime_variable(data: object):
+  return RuntimeVariable(
+    value=parse_str(data["value"]) if "value" in data and data.get("value") is not None else None,
+  )
+
+def serialize_runtime_variable(data: RuntimeVariable) -> object:
+  return {
+    "value": None if data.value is None else serialize_str(data.value),
+  }
+
+class SchunkEGxControlKindEnum(Enum):
+  Move = "move"
+  """Move gripper to target grip diameter"""
 
 def parse_schunk_e_gx_control_kind_enum(data: object) -> SchunkEGxControlKindEnum:
   return SchunkEGxControlKindEnum(data)
@@ -1537,6 +2049,96 @@ def parse_schunk_e_gx_control_kind_enum(data: object) -> SchunkEGxControlKindEnu
 def serialize_schunk_e_gx_control_kind_enum(data: Union[SchunkEGxControlKindEnum, str]) -> object:
   return SchunkEGxControlKindEnum(data).value
 
+@dataclass
+class Sensor:
+  """Individual sensor information"""
+  id: Union[str, None] = None
+  name: Union[str, None] = None
+  kind: Union[str, None] = None
+  sensorValue: Union[str, None] = None
+  equipmentId: 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 Sensor, 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 Sensor, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_kind(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "kind must be of type str for Sensor, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_sensorValue(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "sensorValue must be of type str for Sensor, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_equipmentId(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "equipmentId must be of type str for Sensor, 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_sensorValue(self.sensorValue)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_equipmentId(self.equipmentId)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_sensor(data: object):
+  return Sensor(
+    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,
+    sensorValue=parse_str(data["sensorValue"]) if "sensorValue" in data and data.get("sensorValue") is not None else None,
+    equipmentId=parse_str(data["equipmentId"]) if "equipmentId" in data and data.get("equipmentId") is not None else None,
+  )
+
+def serialize_sensor(data: Sensor) -> 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),
+    "kind": None if data.kind is None else serialize_str(data.kind),
+    "sensorValue": None if data.sensorValue is None else serialize_str(data.sensorValue),
+    "equipmentId": None if data.equipmentId is None else serialize_str(data.equipmentId),
+  }
+
 SkillsList = List[str]
 
 def parse_skills_list(data: object) -> SkillsList:
@@ -1567,7 +2169,7 @@ class SpeechToTextRequest:
 
 def parse_speech_to_text_request(data: object):
   return SpeechToTextRequest(
-    encoded_audio_data=parse_str(data["encoded_audio_data"]) if "encoded_audio_data" in data else None,
+    encoded_audio_data=parse_str(data["encoded_audio_data"]) if "encoded_audio_data" in data and data.get("encoded_audio_data") is not None else None,
   )
 
 def serialize_speech_to_text_request(data: SpeechToTextRequest) -> object:
@@ -1624,8 +2226,8 @@ class StatusVersionData:
 
 def parse_status_version_data(data: object):
   return StatusVersionData(
-    id=parse_str(data["id"]) if "id" in data else None,
-    name=parse_str(data["name"]) if "name" in data else None,
+    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,
   )
 
 def serialize_status_version_data(data: StatusVersionData) -> object:
@@ -1670,8 +2272,8 @@ class TriggerFaultRequest:
 
 def parse_trigger_fault_request(data: object):
   return TriggerFaultRequest(
-    message=parse_str(data["message"]) if "message" in data else None,
-    isRecoverable=parse_bool(data["isRecoverable"]) if "isRecoverable" in data else None,
+    message=parse_str(data["message"]) if "message" in data and data.get("message") is not None else None,
+    isRecoverable=parse_bool(data["isRecoverable"]) if "isRecoverable" in data and data.get("isRecoverable") is not None else None,
   )
 
 def serialize_trigger_fault_request(data: TriggerFaultRequest) -> object:
@@ -1728,9 +2330,9 @@ class ArmPositionUpdateFailureEvent:
 
 def parse_arm_position_update_failure_event(data: object):
   return ArmPositionUpdateFailureEvent(
-    kind=parse_arm_position_update_failure_event_kind(data["kind"]) if "kind" in data else None,
-    reason=parse_str(data["reason"]) if "reason" in data else None,
-    internal_reason=parse_str(data["internal_reason"]) if "internal_reason" in data else None,
+    kind=parse_arm_position_update_failure_event_kind(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    reason=parse_str(data["reason"]) if "reason" in data and data.get("reason") is not None else None,
+    internal_reason=parse_str(data["internal_reason"]) if "internal_reason" in data and data.get("internal_reason") is not None else None,
   )
 
 def serialize_arm_position_update_failure_event(data: ArmPositionUpdateFailureEvent) -> object:
@@ -1771,7 +2373,7 @@ class BrakesState:
 
 def parse_brakes_state(data: object):
   return BrakesState(
-    state=parse_brakes_state_enum(data["state"]) if "state" in data else None,
+    state=parse_brakes_state_enum(data["state"]) if "state" in data and data.get("state") is not None else None,
   )
 
 def serialize_brakes_state(data: BrakesState) -> object:
@@ -1801,7 +2403,7 @@ class CameraIntrinsicsResponse:
 
 def parse_camera_intrinsics_response(data: object):
   return CameraIntrinsicsResponse(
-    intrinsics=parse_camera_intrinsics(data["intrinsics"]) if "intrinsics" in data else None,
+    intrinsics=parse_camera_intrinsics(data["intrinsics"]) if "intrinsics" in data and data.get("intrinsics") is not None else None,
   )
 
 def serialize_camera_intrinsics_response(data: CameraIntrinsicsResponse) -> object:
@@ -1831,7 +2433,7 @@ class CameraFrameRequest:
 
 def parse_camera_frame_request(data: object):
   return CameraFrameRequest(
-    camera_settings=parse_camera_settings(data["camera_settings"]) if "camera_settings" in data else None,
+    camera_settings=parse_camera_settings(data["camera_settings"]) if "camera_settings" in data and data.get("camera_settings") is not None else None,
   )
 
 def serialize_camera_frame_request(data: CameraFrameRequest) -> object:
@@ -1840,1183 +2442,966 @@ def serialize_camera_frame_request(data: CameraFrameRequest) -> object:
   }
 
 @dataclass
-class JointState:
-  """State of a joint"""
-  braked: Union[bool, None] = None
-  connectionStatus: Union[ConnectionStatus, None] = None
-  inCollision: Union[bool, None] = None
-  disturbance: Union[float, None] = None
+class CartesianOffsetResponse:
+  """Response with the cartesian offset value
+"""
+  pose: Union[CartesianPose, None] = None
 
-  def validate_braked(self, value: bool) -> Tuple[bool, str]:
+  def validate_pose(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "pose is required for CartesianOffsetResponse"]
 
-    if not isinstance(value, bool):
-      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose must be of type CartesianPose for CartesianOffsetResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_connectionStatus(self, value: ConnectionStatus) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_pose(self.pose)
+    if not is_valid:
+      raise TypeError(error_str)
 
-    if not ((isinstance(value, str) and ConnectionStatus in ['connected', 'disconnected', 'ready']) or isinstance(value, ConnectionStatus)):
-      return [False, "connectionStatus must be of type ConnectionStatus for JointState, got " + type(value).__name__]
+def parse_cartesian_offset_response(data: object):
+  return CartesianOffsetResponse(
+    pose=parse_cartesian_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
+  )
 
-    return [True, ""]
+def serialize_cartesian_offset_response(data: CartesianOffsetResponse) -> object:
+  return {
+    "pose": serialize_cartesian_pose(data.pose),
+  }
 
-  def validate_inCollision(self, value: bool) -> Tuple[bool, str]:
+@dataclass
+class CartesianPoseResponse:
+  """Response with cartesian pose based on euler pose"""
+  pose: Union[CartesianPose, None] = None
+
+  def validate_pose(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "pose is required for CartesianPoseResponse"]
 
-    if not isinstance(value, bool):
-      return [False, "inCollision must be of type bool for JointState, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose must be of type CartesianPose for CartesianPoseResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_disturbance(self, value: float) -> Tuple[bool, str]:
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_pose(self.pose)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_cartesian_pose_response(data: object):
+  return CartesianPoseResponse(
+    pose=parse_cartesian_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
+  )
+
+def serialize_cartesian_pose_response(data: CartesianPoseResponse) -> object:
+  return {
+    "pose": serialize_cartesian_pose(data.pose),
+  }
+
+@dataclass
+class FlangePositionResponse:
+  """Response with robot flange position
+"""
+  pose: Union[CartesianPose, None] = None
+
+  def validate_pose(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "disturbance must be of type float for JointState, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose must be of type CartesianPose for FlangePositionResponse, 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_braked(self.braked)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_connectionStatus(self.connectionStatus)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_inCollision(self.inCollision)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_disturbance(self.disturbance)
+    is_valid, error_str = self.validate_pose(self.pose)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_joint_state(data: object):
-  return JointState(
-    braked=parse_bool(data["braked"]) if "braked" in data else None,
-    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data else None,
-    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data else None,
-    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data else None,
+def parse_flange_position_response(data: object):
+  return FlangePositionResponse(
+    pose=parse_cartesian_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
   )
 
-def serialize_joint_state(data: JointState) -> object:
+def serialize_flange_position_response(data: FlangePositionResponse) -> object:
   return {
-    "braked": None if data.braked is None else serialize_bool(data.braked),
-    "connectionStatus": None if data.connectionStatus is None else serialize_connection_status(data.connectionStatus),
-    "inCollision": None if data.inCollision is None else serialize_bool(data.inCollision),
-    "disturbance": None if data.disturbance is None else serialize_f_64(data.disturbance),
+    "pose": None if data.pose is None else serialize_cartesian_pose(data.pose),
   }
 
-EnvironmentVariablesList = List[EnvironmentVariable]
+@dataclass
+class JointPoseResponse:
+  """Response with cartesian pose based on joint angles"""
+  pose: Union[CartesianPose, None] = None
 
-def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
-  return [parse_environment_variable(item) for item in data]
+  def validate_pose(self, value: CartesianPose) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "pose is required for JointPoseResponse"]
 
-def serialize_environment_variables_list(data: EnvironmentVariablesList) -> List[object]:
-  return [serialize_environment_variable(item) for item in data]
-
-@dataclass
-class ErrorResponse:
-  """Error Response"""
-  error: Union[ErrorEnum, None] = None
-  message: Union[str, None] = None
-
-  def validate_error(self, value: ErrorEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [False, "error is required for ErrorResponse"]
-
-    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'robot_not_idle', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'recovery_error', 'not_found', 'invalid_space_specified']) or isinstance(value, ErrorEnum)):
-      return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_message(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [False, "message is required for ErrorResponse"]
-
-    if not isinstance(value, str):
-      return [False, "message must be of type str for ErrorResponse, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose must be of type CartesianPose for JointPoseResponse, 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_error(self.error)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_message(self.message)
+    is_valid, error_str = self.validate_pose(self.pose)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_error_response(data: object):
-  return ErrorResponse(
-    error=parse_error_enum(data["error"]) if "error" in data else None,
-    message=parse_str(data["message"]) if "message" in data else None,
+def parse_joint_pose_response(data: object):
+  return JointPoseResponse(
+    pose=parse_cartesian_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
   )
 
-def serialize_error_response(data: ErrorResponse) -> object:
+def serialize_joint_pose_response(data: JointPoseResponse) -> object:
   return {
-    "error": serialize_error_enum(data.error),
-    "message": serialize_str(data.message),
+    "pose": serialize_cartesian_pose(data.pose),
   }
 
 @dataclass
-class ForceUnit:
-  """Reusable Abstraction for force units (eg force, torque)
+class PoseDistanceRequest:
+  """Request: Calculate the distance between two cartesian poses
 """
-  unit_kind: Union[ForceUnitKind, None] = None
-  value: Union[float, None] = None
+  pose1: Union[CartesianPose, None] = None
+  pose2: Union[CartesianPose, None] = None
 
-  def validate_unit_kind(self, value: ForceUnitKind) -> Tuple[bool, str]:
+  def validate_pose1(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
-      return [False, "unit_kind is required for ForceUnit"]
+      return [False, "pose1 is required for PoseDistanceRequest"]
 
-    if not ((isinstance(value, str) and ForceUnitKind in ['newtons', 'pounds']) or isinstance(value, ForceUnitKind)):
-      return [False, "unit_kind must be of type ForceUnitKind for ForceUnit, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose1 must be of type CartesianPose for PoseDistanceRequest, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_value(self, value: float) -> Tuple[bool, str]:
+  def validate_pose2(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "pose2 is required for PoseDistanceRequest"]
 
-    if not isinstance(value, float):
-      return [False, "value must be of type float for ForceUnit, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose2 must be of type CartesianPose for PoseDistanceRequest, 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_unit_kind(self.unit_kind)
+    is_valid, error_str = self.validate_pose1(self.pose1)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_value(self.value)
+    is_valid, error_str = self.validate_pose2(self.pose2)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_force_unit(data: object):
-  return ForceUnit(
-    unit_kind=parse_force_unit_kind(data["unit_kind"]) if "unit_kind" in data else None,
-    value=parse_f_64(data["value"]) if "value" in data else None,
+def parse_pose_distance_request(data: object):
+  return PoseDistanceRequest(
+    pose1=parse_cartesian_pose(data["pose1"]) if "pose1" in data and data.get("pose1") is not None else None,
+    pose2=parse_cartesian_pose(data["pose2"]) if "pose2" in data and data.get("pose2") is not None else None,
   )
 
-def serialize_force_unit(data: ForceUnit) -> object:
+def serialize_pose_distance_request(data: PoseDistanceRequest) -> object:
   return {
-    "unit_kind": serialize_force_unit_kind(data.unit_kind),
-    "value": None if data.value is None else serialize_f_64(data.value),
+    "pose1": serialize_cartesian_pose(data.pose1),
+    "pose2": serialize_cartesian_pose(data.pose2),
   }
 
 @dataclass
-class IOStateResponse:
-  """Response to a query for the current state of I/O."""
-  state: Union[IOStateMap, None] = None
+class PoseOperationsRequest:
+  """Request: Calculate add or substract operations between two cartesian poses
+"""
+  pose1: Union[CartesianPose, None] = None
+  pose2: Union[CartesianPose, None] = None
 
-  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
+  def validate_pose1(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "pose1 is required for PoseOperationsRequest"]
 
-    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
-      return [False, "state must be of type IOStateMap for IOStateResponse, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose1 must be of type CartesianPose for PoseOperationsRequest, got " + type(value).__name__]
 
     return [True, ""]
 
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_state(self.state)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_io_state_response(data: object):
-  return IOStateResponse(
-    state=parse_io_state_map(data["state"]) if "state" in data else None,
-  )
-
-def serialize_io_state_response(data: IOStateResponse) -> object:
-  return {
-    "state": None if data.state is None else serialize_io_state_map(data.state),
-  }
-
-@dataclass
-class IOStateUpdateRequest:
-  """Request to update the state of I/O for multiple ports."""
-  state: Union[IOStateMap, None] = None
-
-  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
+  def validate_pose2(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "pose2 is required for PoseOperationsRequest"]
 
-    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
-      return [False, "state must be of type IOStateMap for IOStateUpdateRequest, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose2 must be of type CartesianPose for PoseOperationsRequest, got " + type(value).__name__]
 
     return [True, ""]
 
   def __post_init__(self):
     # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_state(self.state)
+    is_valid, error_str = self.validate_pose1(self.pose1)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_pose2(self.pose2)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_io_state_update_request(data: object):
-  return IOStateUpdateRequest(
-    state=parse_io_state_map(data["state"]) if "state" in data else None,
+def parse_pose_operations_request(data: object):
+  return PoseOperationsRequest(
+    pose1=parse_cartesian_pose(data["pose1"]) if "pose1" in data and data.get("pose1") is not None else None,
+    pose2=parse_cartesian_pose(data["pose2"]) if "pose2" in data and data.get("pose2") is not None else None,
   )
 
-def serialize_io_state_update_request(data: IOStateUpdateRequest) -> object:
+def serialize_pose_operations_request(data: PoseOperationsRequest) -> object:
   return {
-    "state": None if data.state is None else serialize_io_state_map(data.state),
+    "pose1": serialize_cartesian_pose(data.pose1),
+    "pose2": serialize_cartesian_pose(data.pose2),
   }
 
 @dataclass
-class ArmJointRotations:
-  """Rotational positions of arm joints"""
-  joints: Union[JointRotations, None] = None
+class PoseOperationsResponse:
+  """Response: Operation result between two cartesian poses
+"""
+  pose: Union[CartesianPose, None] = None
 
-  def validate_joints(self, value: JointRotations) -> Tuple[bool, str]:
+  def validate_pose(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
-      return [False, "joints is required for ArmJointRotations"]
+      return [False, "pose is required for PoseOperationsResponse"]
 
-    if not (isinstance(value, tuple) and len(value) == 6):
-      return [False, "joints must be of type JointRotations for ArmJointRotations, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose must be of type CartesianPose for PoseOperationsResponse, 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_joints(self.joints)
+    is_valid, error_str = self.validate_pose(self.pose)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_arm_joint_rotations(data: object):
-  return ArmJointRotations(
-    joints=parse_joint_rotations(data["joints"]) if "joints" in data else None,
+def parse_pose_operations_response(data: object):
+  return PoseOperationsResponse(
+    pose=parse_cartesian_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
   )
 
-def serialize_arm_joint_rotations(data: ArmJointRotations) -> object:
+def serialize_pose_operations_response(data: PoseOperationsResponse) -> object:
   return {
-    "joints": serialize_joint_rotations(data.joints),
+    "pose": serialize_cartesian_pose(data.pose),
   }
 
 @dataclass
-class LinearUnit:
-  """Reusable Abstraction for linear units (eg distance, position, offset)
+class TooltipPositionResponse:
+  """Response with robot tooltip position
 """
-  unit_kind: Union[LinearUnitKind, None] = None
-  value: Union[float, None] = None
+  pose: Union[CartesianPose, None] = None
 
-  def validate_unit_kind(self, value: LinearUnitKind) -> Tuple[bool, str]:
-    if value is None:
-      return [False, "unit_kind is required for LinearUnit"]
-
-    if not ((isinstance(value, str) and LinearUnitKind in ['millimeters', 'centimeters', 'meters', 'inches', 'feet']) or isinstance(value, LinearUnitKind)):
-      return [False, "unit_kind must be of type LinearUnitKind for LinearUnit, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_value(self, value: float) -> Tuple[bool, str]:
+  def validate_pose(self, value: CartesianPose) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "value must be of type float for LinearUnit, got " + type(value).__name__]
+    if not isinstance(value, CartesianPose):
+      return [False, "pose must be of type CartesianPose for TooltipPositionResponse, 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_unit_kind(self.unit_kind)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_value(self.value)
+    is_valid, error_str = self.validate_pose(self.pose)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_linear_unit(data: object):
-  return LinearUnit(
-    unit_kind=parse_linear_unit_kind(data["unit_kind"]) if "unit_kind" in data else None,
-    value=parse_f_64(data["value"]) if "value" in data else None,
+def parse_tooltip_position_response(data: object):
+  return TooltipPositionResponse(
+    pose=parse_cartesian_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
   )
 
-def serialize_linear_unit(data: LinearUnit) -> object:
+def serialize_tooltip_position_response(data: TooltipPositionResponse) -> object:
   return {
-    "unit_kind": serialize_linear_unit_kind(data.unit_kind),
-    "value": None if data.value is None else serialize_f_64(data.value),
+    "pose": None if data.pose is None else serialize_cartesian_pose(data.pose),
   }
 
 @dataclass
-class Position:
-  """Position of an object in 3D space. All empty values default to 0"""
-  unit_kind: Union[LinearUnitKind, None] = None
-  x: Union[float, None] = None
-  y: Union[float, None] = None
-  z: Union[float, None] = None
+class JointState:
+  """State of a joint"""
+  braked: Union[bool, None] = None
+  connectionStatus: Union[ConnectionStatus, None] = None
+  inCollision: Union[bool, None] = None
+  disturbance: Union[float, None] = None
 
-  def validate_unit_kind(self, value: LinearUnitKind) -> Tuple[bool, str]:
+  def validate_braked(self, value: bool) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not ((isinstance(value, str) and LinearUnitKind in ['millimeters', 'centimeters', 'meters', 'inches', 'feet']) or isinstance(value, LinearUnitKind)):
-      return [False, "unit_kind must be of type LinearUnitKind for Position, got " + type(value).__name__]
+    if not isinstance(value, bool):
+      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_x(self, value: float) -> Tuple[bool, str]:
+  def validate_connectionStatus(self, value: ConnectionStatus) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "x must be of type float for Position, got " + type(value).__name__]
+    if not ((isinstance(value, str) and ConnectionStatus in ['connected', 'disconnected', 'ready']) or isinstance(value, ConnectionStatus)):
+      return [False, "connectionStatus must be of type ConnectionStatus for JointState, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_y(self, value: float) -> Tuple[bool, str]:
+  def validate_inCollision(self, value: bool) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "y must be of type float for Position, got " + type(value).__name__]
+    if not isinstance(value, bool):
+      return [False, "inCollision must be of type bool for JointState, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_z(self, value: float) -> Tuple[bool, str]:
+  def validate_disturbance(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "z must be of type float for Position, got " + type(value).__name__]
+      return [False, "disturbance must be of type float for JointState, 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_unit_kind(self.unit_kind)
+    is_valid, error_str = self.validate_braked(self.braked)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_x(self.x)
+    is_valid, error_str = self.validate_connectionStatus(self.connectionStatus)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_y(self.y)
+    is_valid, error_str = self.validate_inCollision(self.inCollision)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_z(self.z)
+    is_valid, error_str = self.validate_disturbance(self.disturbance)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_position(data: object):
-  return Position(
-    unit_kind=parse_linear_unit_kind(data["unit_kind"]) if "unit_kind" in data else None,
-    x=parse_f_64(data["x"]) if "x" in data else None,
-    y=parse_f_64(data["y"]) if "y" in data else None,
-    z=parse_f_64(data["z"]) if "z" in data else None,
+def parse_joint_state(data: object):
+  return JointState(
+    braked=parse_bool(data["braked"]) if "braked" in data and data.get("braked") is not None else None,
+    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data and data.get("connectionStatus") is not None else None,
+    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data and data.get("inCollision") is not None else None,
+    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None else None,
   )
 
-def serialize_position(data: Position) -> object:
+def serialize_joint_state(data: JointState) -> object:
   return {
-    "unit_kind": None if data.unit_kind is None else serialize_linear_unit_kind(data.unit_kind),
-    "x": None if data.x is None else serialize_f_64(data.x),
-    "y": None if data.y is None else serialize_f_64(data.y),
-    "z": None if data.z is None else serialize_f_64(data.z),
+    "braked": None if data.braked is None else serialize_bool(data.braked),
+    "connectionStatus": None if data.connectionStatus is None else serialize_connection_status(data.connectionStatus),
+    "inCollision": None if data.inCollision is None else serialize_bool(data.inCollision),
+    "disturbance": None if data.disturbance is None else serialize_f_64(data.disturbance),
   }
 
-@dataclass
-class OnRobot2FG14GripperConfiguration:
-  """Configuration for OnRobot 2FG14 Gripper"""
-  grip_kind: Union[OnRobotGripKindEnum, None] = None
-  grip_detected: Union[bool, None] = None
-  normalized_width_inner: Union[float, None] = None
-  normalized_width_outer: Union[float, None] = None
-  width_inner: Union[float, None] = None
-  min_width_inner: Union[float, None] = None
-  max_width_inner: Union[float, None] = None
-  width_outer: Union[float, None] = None
-  min_width_outer: Union[float, None] = None
-  max_width_outer: Union[float, None] = None
-  force: Union[float, None] = None
-  max_force: Union[float, None] = None
-  finger_mounting_position: Union[str, None] = None
-  finger_offset: Union[float, None] = None
-  finger_angle: Union[float, None] = None
-  finger_length: Union[float, None] = None
-  finger_height: Union[float, None] = None
-  linear_sensor_error: Union[bool, None] = None
-  uncalibrated_error: Union[bool, None] = None
-
-  def validate_grip_kind(self, value: OnRobotGripKindEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
-      return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
+EnvironmentVariablesList = List[EnvironmentVariable]
 
-  def validate_grip_detected(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
+  return [parse_environment_variable(item) for item in data]
 
-    if not isinstance(value, bool):
-      return [False, "grip_detected must be of type bool for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+def serialize_environment_variables_list(data: EnvironmentVariablesList) -> List[object]:
+  return [serialize_environment_variable(item) for item in data]
 
-    return [True, ""]
+@dataclass
+class ErrorResponse:
+  """Error Response"""
+  error: Union[ErrorEnum, None] = None
+  message: Union[str, None] = None
 
-  def validate_normalized_width_inner(self, value: float) -> Tuple[bool, str]:
+  def validate_error(self, value: ErrorEnum) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "error is required for ErrorResponse"]
 
-    if not isinstance(value, float):
-      return [False, "normalized_width_inner must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'robot_not_idle', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'recovery_error', 'not_found', 'invalid_space_specified']) or isinstance(value, ErrorEnum)):
+      return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_normalized_width_outer(self, value: float) -> Tuple[bool, str]:
+  def validate_message(self, value: str) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "message is required for ErrorResponse"]
 
-    if not isinstance(value, float):
-      return [False, "normalized_width_outer must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, str):
+      return [False, "message must be of type str for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_width_inner(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "width_inner must be of type float for OnRobot2FG14GripperConfiguration, 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_error(self.error)
+    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 validate_min_width_inner(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_error_response(data: object):
+  return ErrorResponse(
+    error=parse_error_enum(data["error"]) if "error" in data and data.get("error") is not None else None,
+    message=parse_str(data["message"]) if "message" in data and data.get("message") is not None else None,
+  )
 
-    if not isinstance(value, float):
-      return [False, "min_width_inner must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+def serialize_error_response(data: ErrorResponse) -> object:
+  return {
+    "error": serialize_error_enum(data.error),
+    "message": serialize_str(data.message),
+  }
 
-    return [True, ""]
+@dataclass
+class CartesianOffsetRequest:
+  """Request to retrieve the cartesian offset based on robot position
+"""
+  pose: Union[EulerPose, None] = None
 
-  def validate_max_width_inner(self, value: float) -> Tuple[bool, str]:
+  def validate_pose(self, value: EulerPose) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "pose is required for CartesianOffsetRequest"]
 
-    if not isinstance(value, float):
-      return [False, "max_width_inner must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, EulerPose):
+      return [False, "pose must be of type EulerPose for CartesianOffsetRequest, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_width_outer(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "width_outer must be of type float for OnRobot2FG14GripperConfiguration, 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_pose(self.pose)
+    if not is_valid:
+      raise TypeError(error_str)
 
-  def validate_min_width_outer(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_cartesian_offset_request(data: object):
+  return CartesianOffsetRequest(
+    pose=parse_euler_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
+  )
 
-    if not isinstance(value, float):
-      return [False, "min_width_outer must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+def serialize_cartesian_offset_request(data: CartesianOffsetRequest) -> object:
+  return {
+    "pose": serialize_euler_pose(data.pose),
+  }
 
-    return [True, ""]
+@dataclass
+class CartesianPoseRequest:
+  """Request to transform the euler pose to cartesian pose"""
+  pose: Union[EulerPose, None] = None
 
-  def validate_max_width_outer(self, value: float) -> Tuple[bool, str]:
+  def validate_pose(self, value: EulerPose) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "pose is required for CartesianPoseRequest"]
 
-    if not isinstance(value, float):
-      return [False, "max_width_outer must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, EulerPose):
+      return [False, "pose must be of type EulerPose for CartesianPoseRequest, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_force(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "force must be of type float for OnRobot2FG14GripperConfiguration, 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_pose(self.pose)
+    if not is_valid:
+      raise TypeError(error_str)
 
-  def validate_max_force(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_cartesian_pose_request(data: object):
+  return CartesianPoseRequest(
+    pose=parse_euler_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
+  )
 
-    if not isinstance(value, float):
-      return [False, "max_force must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+def serialize_cartesian_pose_request(data: CartesianPoseRequest) -> object:
+  return {
+    "pose": serialize_euler_pose(data.pose),
+  }
 
-    return [True, ""]
+@dataclass
+class ForceUnit:
+  """Reusable Abstraction for force units (eg force, torque)
+"""
+  unit_kind: Union[ForceUnitKind, None] = None
+  value: Union[float, None] = None
 
-  def validate_finger_mounting_position(self, value: str) -> Tuple[bool, str]:
+  def validate_unit_kind(self, value: ForceUnitKind) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "unit_kind is required for ForceUnit"]
 
-    if not isinstance(value, str):
-      return [False, "finger_mounting_position must be of type str for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not ((isinstance(value, str) and ForceUnitKind in ['newtons', 'pounds']) or isinstance(value, ForceUnitKind)):
+      return [False, "unit_kind must be of type ForceUnitKind for ForceUnit, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_finger_offset(self, value: float) -> Tuple[bool, str]:
+  def validate_value(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "finger_offset must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+      return [False, "value must be of type float for ForceUnit, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_finger_angle(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_unit_kind(self.unit_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_value(self.value)
+    if not is_valid:
+      raise TypeError(error_str)
 
-    if not isinstance(value, float):
-      return [False, "finger_angle must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+def parse_force_unit(data: object):
+  return ForceUnit(
+    unit_kind=parse_force_unit_kind(data["unit_kind"]) if "unit_kind" in data and data.get("unit_kind") is not None else None,
+    value=parse_f_64(data["value"]) if "value" in data and data.get("value") is not None else None,
+  )
 
-    return [True, ""]
+def serialize_force_unit(data: ForceUnit) -> object:
+  return {
+    "unit_kind": serialize_force_unit_kind(data.unit_kind),
+    "value": None if data.value is None else serialize_f_64(data.value),
+  }
 
-  def validate_finger_length(self, value: float) -> Tuple[bool, str]:
+@dataclass
+class GripperConfiguration:
+  """Configuration of gripper, also known as End Effector"""
+  kind: Union[GripperKindEnum, None] = None
+  dh_ag: Union[DHAGGripperConfiguration, None] = None
+  dh_pgc: Union[DHPGCGripperConfiguration, None] = None
+  dh_cgi: Union[DHCGIGripperConfiguration, None] = None
+
+  def validate_kind(self, value: GripperKindEnum) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "kind is required for GripperConfiguration"]
 
-    if not isinstance(value, float):
-      return [False, "finger_length must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
+      return [False, "kind must be of type GripperKindEnum for GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_finger_height(self, value: float) -> Tuple[bool, str]:
+  def validate_dh_ag(self, value: DHAGGripperConfiguration) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "finger_height must be of type float for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, DHAGGripperConfiguration):
+      return [False, "dh_ag must be of type DHAGGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_linear_sensor_error(self, value: bool) -> Tuple[bool, str]:
+  def validate_dh_pgc(self, value: DHPGCGripperConfiguration) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "linear_sensor_error must be of type bool for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, DHPGCGripperConfiguration):
+      return [False, "dh_pgc must be of type DHPGCGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_uncalibrated_error(self, value: bool) -> Tuple[bool, str]:
+  def validate_dh_cgi(self, value: DHCGIGripperConfiguration) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "uncalibrated_error must be of type bool for OnRobot2FG14GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, DHCGIGripperConfiguration):
+      return [False, "dh_cgi must be of type DHCGIGripperConfiguration for GripperConfiguration, 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_grip_kind(self.grip_kind)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_grip_detected(self.grip_detected)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_normalized_width_inner(self.normalized_width_inner)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_normalized_width_outer(self.normalized_width_outer)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_width_inner(self.width_inner)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_min_width_inner(self.min_width_inner)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_max_width_inner(self.max_width_inner)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_width_outer(self.width_outer)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_min_width_outer(self.min_width_outer)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_max_width_outer(self.max_width_outer)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_force(self.force)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_max_force(self.max_force)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_mounting_position(self.finger_mounting_position)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_offset(self.finger_offset)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_angle(self.finger_angle)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_length(self.finger_length)
+    is_valid, error_str = self.validate_kind(self.kind)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_height(self.finger_height)
+    is_valid, error_str = self.validate_dh_ag(self.dh_ag)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_linear_sensor_error(self.linear_sensor_error)
+    is_valid, error_str = self.validate_dh_pgc(self.dh_pgc)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_uncalibrated_error(self.uncalibrated_error)
+    is_valid, error_str = self.validate_dh_cgi(self.dh_cgi)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_on_robot_2_fg_14_gripper_configuration(data: object):
-  return OnRobot2FG14GripperConfiguration(
-    grip_kind=parse_on_robot_grip_kind_enum(data["grip_kind"]) if "grip_kind" in data else None,
-    grip_detected=parse_bool(data["grip_detected"]) if "grip_detected" in data else None,
-    normalized_width_inner=parse_f_64(data["normalized_width_inner"]) if "normalized_width_inner" in data else None,
-    normalized_width_outer=parse_f_64(data["normalized_width_outer"]) if "normalized_width_outer" in data else None,
-    width_inner=parse_f_64(data["width_inner"]) if "width_inner" in data else None,
-    min_width_inner=parse_f_64(data["min_width_inner"]) if "min_width_inner" in data else None,
-    max_width_inner=parse_f_64(data["max_width_inner"]) if "max_width_inner" in data else None,
-    width_outer=parse_f_64(data["width_outer"]) if "width_outer" in data else None,
-    min_width_outer=parse_f_64(data["min_width_outer"]) if "min_width_outer" in data else None,
-    max_width_outer=parse_f_64(data["max_width_outer"]) if "max_width_outer" in data else None,
-    force=parse_f_64(data["force"]) if "force" in data else None,
-    max_force=parse_f_64(data["max_force"]) if "max_force" in data else None,
-    finger_mounting_position=parse_str(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
-    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data else None,
-    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data else None,
-    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data else None,
-    finger_height=parse_f_64(data["finger_height"]) if "finger_height" in data else None,
-    linear_sensor_error=parse_bool(data["linear_sensor_error"]) if "linear_sensor_error" in data else None,
-    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data else None,
+def parse_gripper_configuration(data: object):
+  return GripperConfiguration(
+    kind=parse_gripper_kind_enum(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    dh_ag=parse_dhag_gripper_configuration(data["dh_ag"]) if "dh_ag" in data and data.get("dh_ag") is not None else None,
+    dh_pgc=parse_dhpgc_gripper_configuration(data["dh_pgc"]) if "dh_pgc" in data and data.get("dh_pgc") is not None else None,
+    dh_cgi=parse_dhcgi_gripper_configuration(data["dh_cgi"]) if "dh_cgi" in data and data.get("dh_cgi") is not None else None,
   )
 
-def serialize_on_robot_2_fg_14_gripper_configuration(data: OnRobot2FG14GripperConfiguration) -> object:
+def serialize_gripper_configuration(data: GripperConfiguration) -> object:
   return {
-    "grip_kind": None if data.grip_kind is None else serialize_on_robot_grip_kind_enum(data.grip_kind),
-    "grip_detected": None if data.grip_detected is None else serialize_bool(data.grip_detected),
-    "normalized_width_inner": None if data.normalized_width_inner is None else serialize_f_64(data.normalized_width_inner),
-    "normalized_width_outer": None if data.normalized_width_outer is None else serialize_f_64(data.normalized_width_outer),
-    "width_inner": None if data.width_inner is None else serialize_f_64(data.width_inner),
-    "min_width_inner": None if data.min_width_inner is None else serialize_f_64(data.min_width_inner),
-    "max_width_inner": None if data.max_width_inner is None else serialize_f_64(data.max_width_inner),
-    "width_outer": None if data.width_outer is None else serialize_f_64(data.width_outer),
-    "min_width_outer": None if data.min_width_outer is None else serialize_f_64(data.min_width_outer),
-    "max_width_outer": None if data.max_width_outer is None else serialize_f_64(data.max_width_outer),
-    "force": None if data.force is None else serialize_f_64(data.force),
-    "max_force": None if data.max_force is None else serialize_f_64(data.max_force),
-    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_str(data.finger_mounting_position),
-    "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
-    "finger_angle": None if data.finger_angle is None else serialize_f_64(data.finger_angle),
-    "finger_length": None if data.finger_length is None else serialize_f_64(data.finger_length),
-    "finger_height": None if data.finger_height is None else serialize_f_64(data.finger_height),
-    "linear_sensor_error": None if data.linear_sensor_error is None else serialize_bool(data.linear_sensor_error),
-    "uncalibrated_error": None if data.uncalibrated_error is None else serialize_bool(data.uncalibrated_error),
+    "kind": serialize_gripper_kind_enum(data.kind),
+    "dh_ag": None if data.dh_ag is None else serialize_dhag_gripper_configuration(data.dh_ag),
+    "dh_pgc": None if data.dh_pgc is None else serialize_dhpgc_gripper_configuration(data.dh_pgc),
+    "dh_cgi": None if data.dh_cgi is None else serialize_dhcgi_gripper_configuration(data.dh_cgi),
   }
 
 @dataclass
-class OnRobot2FG7GripperConfiguration:
-  """Configuration for OnRobot 2FG7 Gripper"""
-  grip_kind: Union[OnRobotGripKindEnum, None] = None
-  grip_detected: Union[bool, None] = None
-  normalized_width_inner: Union[float, None] = None
-  normalized_width_outer: Union[float, None] = None
-  width_inner: Union[float, None] = None
-  min_width_inner: Union[float, None] = None
-  max_width_inner: Union[float, None] = None
-  width_outer: Union[float, None] = None
-  min_width_outer: Union[float, None] = None
-  max_width_outer: Union[float, None] = None
-  force: Union[float, None] = None
-  max_force: Union[float, None] = None
-  finger_mounting_position: Union[str, None] = None
-  finger_offset: Union[float, None] = None
-  finger_angle: Union[float, None] = None
-  finger_length: Union[float, None] = None
-  finger_height: Union[float, None] = None
-  linear_sensor_error: Union[bool, None] = None
-  uncalibrated_error: Union[bool, None] = None
-
-  def validate_grip_kind(self, value: OnRobotGripKindEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
-      return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_grip_detected(self, value: bool) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, bool):
-      return [False, "grip_detected must be of type bool for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_normalized_width_inner(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "normalized_width_inner must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_normalized_width_outer(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "normalized_width_outer must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
+class IOStateResponse:
+  """Response to a query for the current state of I/O."""
+  state: Union[IOStateMap, None] = None
 
-  def validate_width_inner(self, value: float) -> Tuple[bool, str]:
+  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "width_inner must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "state must be of type IOStateMap for IOStateResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_min_width_inner(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "min_width_inner must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
 
-  def validate_max_width_inner(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_io_state_response(data: object):
+  return IOStateResponse(
+    state=parse_io_state_map(data["state"]) if "state" in data and data.get("state") is not None else None,
+  )
 
-    if not isinstance(value, float):
-      return [False, "max_width_inner must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+def serialize_io_state_response(data: IOStateResponse) -> object:
+  return {
+    "state": None if data.state is None else serialize_io_state_map(data.state),
+  }
 
-    return [True, ""]
+@dataclass
+class IOStateUpdateRequest:
+  """Request to update the state of I/O for multiple ports."""
+  state: Union[IOStateMap, None] = None
 
-  def validate_width_outer(self, value: float) -> Tuple[bool, str]:
+  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "width_outer must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "state must be of type IOStateMap for IOStateUpdateRequest, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_min_width_outer(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "min_width_outer must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
 
-  def validate_max_width_outer(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_io_state_update_request(data: object):
+  return IOStateUpdateRequest(
+    state=parse_io_state_map(data["state"]) if "state" in data and data.get("state") is not None else None,
+  )
 
-    if not isinstance(value, float):
-      return [False, "max_width_outer must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+def serialize_io_state_update_request(data: IOStateUpdateRequest) -> object:
+  return {
+    "state": None if data.state is None else serialize_io_state_map(data.state),
+  }
 
-    return [True, ""]
+@dataclass
+class JointPoseRequest:
+  """Request to transform the joint angles to cartesian pose"""
+  pose: Union[JointAngles, None] = None
 
-  def validate_force(self, value: float) -> Tuple[bool, str]:
+  def validate_pose(self, value: JointAngles) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "pose is required for JointPoseRequest"]
 
-    if not isinstance(value, float):
-      return [False, "force must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, JointAngles):
+      return [False, "pose must be of type JointAngles for JointPoseRequest, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_max_force(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, float):
-      return [False, "max_force must be of type float for OnRobot2FG7GripperConfiguration, 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_pose(self.pose)
+    if not is_valid:
+      raise TypeError(error_str)
 
-  def validate_finger_mounting_position(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_joint_pose_request(data: object):
+  return JointPoseRequest(
+    pose=parse_joint_angles(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
+  )
 
-    if not isinstance(value, str):
-      return [False, "finger_mounting_position must be of type str for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+def serialize_joint_pose_request(data: JointPoseRequest) -> object:
+  return {
+    "pose": serialize_joint_angles(data.pose),
+  }
 
-    return [True, ""]
+@dataclass
+class JointsPositionResponse:
+  """Response with robot joints position
+"""
+  pose: Union[JointAngles, None] = None
 
-  def validate_finger_offset(self, value: float) -> Tuple[bool, str]:
+  def validate_pose(self, value: JointAngles) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "finger_offset must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, JointAngles):
+      return [False, "pose must be of type JointAngles for JointsPositionResponse, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_finger_angle(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_pose(self.pose)
+    if not is_valid:
+      raise TypeError(error_str)
 
-    if not isinstance(value, float):
-      return [False, "finger_angle must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+def parse_joints_position_response(data: object):
+  return JointsPositionResponse(
+    pose=parse_joint_angles(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
+  )
 
-    return [True, ""]
+def serialize_joints_position_response(data: JointsPositionResponse) -> object:
+  return {
+    "pose": None if data.pose is None else serialize_joint_angles(data.pose),
+  }
+
+@dataclass
+class ArmJointRotations:
+  """Rotational positions of arm joints"""
+  joints: Union[JointRotations, None] = None
 
-  def validate_finger_length(self, value: float) -> Tuple[bool, str]:
+  def validate_joints(self, value: JointRotations) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "joints is required for ArmJointRotations"]
 
-    if not isinstance(value, float):
-      return [False, "finger_length must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not (isinstance(value, tuple) and len(value) == 6):
+      return [False, "joints must be of type JointRotations for ArmJointRotations, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_finger_height(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_joints(self.joints)
+    if not is_valid:
+      raise TypeError(error_str)
 
-    if not isinstance(value, float):
-      return [False, "finger_height must be of type float for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+def parse_arm_joint_rotations(data: object):
+  return ArmJointRotations(
+    joints=parse_joint_rotations(data["joints"]) if "joints" in data and data.get("joints") is not None else None,
+  )
 
-    return [True, ""]
+def serialize_arm_joint_rotations(data: ArmJointRotations) -> object:
+  return {
+    "joints": serialize_joint_rotations(data.joints),
+  }
+
+@dataclass
+class LinearUnit:
+  """Reusable Abstraction for linear units (eg distance, position, offset)
+"""
+  unit_kind: Union[LinearUnitKind, None] = None
+  value: Union[float, None] = None
 
-  def validate_linear_sensor_error(self, value: bool) -> Tuple[bool, str]:
+  def validate_unit_kind(self, value: LinearUnitKind) -> Tuple[bool, str]:
     if value is None:
-      return [True, ""]
+      return [False, "unit_kind is required for LinearUnit"]
 
-    if not isinstance(value, bool):
-      return [False, "linear_sensor_error must be of type bool for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not ((isinstance(value, str) and LinearUnitKind in ['millimeters', 'centimeters', 'meters', 'inches', 'feet']) or isinstance(value, LinearUnitKind)):
+      return [False, "unit_kind must be of type LinearUnitKind for LinearUnit, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_uncalibrated_error(self, value: bool) -> Tuple[bool, str]:
+  def validate_value(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "uncalibrated_error must be of type bool for OnRobot2FG7GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "value must be of type float for LinearUnit, 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_grip_kind(self.grip_kind)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_grip_detected(self.grip_detected)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_normalized_width_inner(self.normalized_width_inner)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_normalized_width_outer(self.normalized_width_outer)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_width_inner(self.width_inner)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_min_width_inner(self.min_width_inner)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_max_width_inner(self.max_width_inner)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_width_outer(self.width_outer)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_min_width_outer(self.min_width_outer)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_max_width_outer(self.max_width_outer)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_force(self.force)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_max_force(self.max_force)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_mounting_position(self.finger_mounting_position)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_offset(self.finger_offset)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_angle(self.finger_angle)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_length(self.finger_length)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_height(self.finger_height)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_linear_sensor_error(self.linear_sensor_error)
+    is_valid, error_str = self.validate_unit_kind(self.unit_kind)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_uncalibrated_error(self.uncalibrated_error)
+    is_valid, error_str = self.validate_value(self.value)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_on_robot_2_fg_7_gripper_configuration(data: object):
-  return OnRobot2FG7GripperConfiguration(
-    grip_kind=parse_on_robot_grip_kind_enum(data["grip_kind"]) if "grip_kind" in data else None,
-    grip_detected=parse_bool(data["grip_detected"]) if "grip_detected" in data else None,
-    normalized_width_inner=parse_f_64(data["normalized_width_inner"]) if "normalized_width_inner" in data else None,
-    normalized_width_outer=parse_f_64(data["normalized_width_outer"]) if "normalized_width_outer" in data else None,
-    width_inner=parse_f_64(data["width_inner"]) if "width_inner" in data else None,
-    min_width_inner=parse_f_64(data["min_width_inner"]) if "min_width_inner" in data else None,
-    max_width_inner=parse_f_64(data["max_width_inner"]) if "max_width_inner" in data else None,
-    width_outer=parse_f_64(data["width_outer"]) if "width_outer" in data else None,
-    min_width_outer=parse_f_64(data["min_width_outer"]) if "min_width_outer" in data else None,
-    max_width_outer=parse_f_64(data["max_width_outer"]) if "max_width_outer" in data else None,
-    force=parse_f_64(data["force"]) if "force" in data else None,
-    max_force=parse_f_64(data["max_force"]) if "max_force" in data else None,
-    finger_mounting_position=parse_str(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
-    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data else None,
-    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data else None,
-    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data else None,
-    finger_height=parse_f_64(data["finger_height"]) if "finger_height" in data else None,
-    linear_sensor_error=parse_bool(data["linear_sensor_error"]) if "linear_sensor_error" in data else None,
-    uncalibrated_error=parse_bool(data["uncalibrated_error"]) if "uncalibrated_error" in data else None,
+def parse_linear_unit(data: object):
+  return LinearUnit(
+    unit_kind=parse_linear_unit_kind(data["unit_kind"]) if "unit_kind" in data and data.get("unit_kind") is not None else None,
+    value=parse_f_64(data["value"]) if "value" in data and data.get("value") is not None else None,
   )
 
-def serialize_on_robot_2_fg_7_gripper_configuration(data: OnRobot2FG7GripperConfiguration) -> object:
+def serialize_linear_unit(data: LinearUnit) -> object:
   return {
-    "grip_kind": None if data.grip_kind is None else serialize_on_robot_grip_kind_enum(data.grip_kind),
-    "grip_detected": None if data.grip_detected is None else serialize_bool(data.grip_detected),
-    "normalized_width_inner": None if data.normalized_width_inner is None else serialize_f_64(data.normalized_width_inner),
-    "normalized_width_outer": None if data.normalized_width_outer is None else serialize_f_64(data.normalized_width_outer),
-    "width_inner": None if data.width_inner is None else serialize_f_64(data.width_inner),
-    "min_width_inner": None if data.min_width_inner is None else serialize_f_64(data.min_width_inner),
-    "max_width_inner": None if data.max_width_inner is None else serialize_f_64(data.max_width_inner),
-    "width_outer": None if data.width_outer is None else serialize_f_64(data.width_outer),
-    "min_width_outer": None if data.min_width_outer is None else serialize_f_64(data.min_width_outer),
-    "max_width_outer": None if data.max_width_outer is None else serialize_f_64(data.max_width_outer),
-    "force": None if data.force is None else serialize_f_64(data.force),
-    "max_force": None if data.max_force is None else serialize_f_64(data.max_force),
-    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_str(data.finger_mounting_position),
-    "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
-    "finger_angle": None if data.finger_angle is None else serialize_f_64(data.finger_angle),
-    "finger_length": None if data.finger_length is None else serialize_f_64(data.finger_length),
-    "finger_height": None if data.finger_height is None else serialize_f_64(data.finger_height),
-    "linear_sensor_error": None if data.linear_sensor_error is None else serialize_bool(data.linear_sensor_error),
-    "uncalibrated_error": None if data.uncalibrated_error is None else serialize_bool(data.uncalibrated_error),
+    "unit_kind": serialize_linear_unit_kind(data.unit_kind),
+    "value": None if data.value is None else serialize_f_64(data.value),
   }
 
 @dataclass
-class OnRobot3FG15GripperConfiguration:
-  """Configuration for OnRobot 3FG15 Gripper"""
-  grip_detected: Union[bool, None] = None
-  force_grip_detected: Union[bool, None] = None
-  calibration_ok: Union[bool, None] = None
-  diameter: Union[float, None] = None
-  grip_kind: Union[OnRobotGripKindEnum, None] = None
-  finger_angle: Union[float, None] = None
-  force_applied_fraction: Union[float, None] = None
-  force_applied_newtons: Union[float, None] = None
-  target_force_newtons: Union[float, None] = None
-  finger_length: Union[float, None] = None
-  finger_mounting_position: Union[float, None] = None
-  finger_offset: Union[float, None] = None
+class Position:
+  """Position of an object in 3D space. All empty values default to 0"""
+  unit_kind: Union[LinearUnitKind, None] = None
+  x: Union[float, None] = None
+  y: Union[float, None] = None
+  z: Union[float, None] = None
 
-  def validate_grip_detected(self, value: bool) -> Tuple[bool, str]:
+  def validate_unit_kind(self, value: LinearUnitKind) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "grip_detected must be of type bool for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+    if not ((isinstance(value, str) and LinearUnitKind in ['millimeters', 'centimeters', 'meters', 'inches', 'feet']) or isinstance(value, LinearUnitKind)):
+      return [False, "unit_kind must be of type LinearUnitKind for Position, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_force_grip_detected(self, value: bool) -> Tuple[bool, str]:
+  def validate_x(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "force_grip_detected must be of type bool for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "x must be of type float for Position, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_calibration_ok(self, value: bool) -> Tuple[bool, str]:
+  def validate_y(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, bool):
-      return [False, "calibration_ok must be of type bool for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+    if not isinstance(value, float):
+      return [False, "y must be of type float for Position, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_diameter(self, value: float) -> Tuple[bool, str]:
+  def validate_z(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "diameter must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+      return [False, "z must be of type float for Position, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_grip_kind(self, value: OnRobotGripKindEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not ((isinstance(value, str) and OnRobotGripKindEnum in ['inward', 'outward']) or isinstance(value, OnRobotGripKindEnum)):
-      return [False, "grip_kind must be of type OnRobotGripKindEnum for OnRobot3FG15GripperConfiguration, 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_unit_kind(self.unit_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_x(self.x)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_y(self.y)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_z(self.z)
+    if not is_valid:
+      raise TypeError(error_str)
 
-  def validate_finger_angle(self, value: float) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
+def parse_position(data: object):
+  return Position(
+    unit_kind=parse_linear_unit_kind(data["unit_kind"]) if "unit_kind" in data and data.get("unit_kind") is not None else None,
+    x=parse_f_64(data["x"]) if "x" in data and data.get("x") is not None else None,
+    y=parse_f_64(data["y"]) if "y" in data and data.get("y") is not None else None,
+    z=parse_f_64(data["z"]) if "z" in data and data.get("z") is not None else None,
+  )
 
-    if not isinstance(value, float):
-      return [False, "finger_angle must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+def serialize_position(data: Position) -> object:
+  return {
+    "unit_kind": None if data.unit_kind is None else serialize_linear_unit_kind(data.unit_kind),
+    "x": None if data.x is None else serialize_f_64(data.x),
+    "y": None if data.y is None else serialize_f_64(data.y),
+    "z": None if data.z is None else serialize_f_64(data.z),
+  }
 
-    return [True, ""]
+@dataclass
+class SpeedProfile:
+  """Speed profile/limits for arm movements"""
+  max_joint_speeds: Union[MaxJointSpeeds, None] = None
+  max_joint_accelerations: Union[MaxJointAcclerations, None] = None
+  max_tooltip_speed: Union[float, None] = None
+  base_acceleration_scaling: Union[float, None] = None
+  base_velocity_scaling: Union[float, None] = None
+  scaling_factor: Union[float, None] = None
 
-  def validate_force_applied_fraction(self, value: float) -> Tuple[bool, str]:
+  def validate_max_joint_speeds(self, value: MaxJointSpeeds) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "force_applied_fraction must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+    if not (isinstance(value, tuple) and len(value) == 6):
+      return [False, "max_joint_speeds must be of type MaxJointSpeeds for SpeedProfile, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_force_applied_newtons(self, value: float) -> Tuple[bool, str]:
+  def validate_max_joint_accelerations(self, value: MaxJointAcclerations) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, float):
-      return [False, "force_applied_newtons must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+    if not (isinstance(value, tuple) and len(value) == 6):
+      return [False, "max_joint_accelerations must be of type MaxJointAcclerations for SpeedProfile, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_target_force_newtons(self, value: float) -> Tuple[bool, str]:
+  def validate_max_tooltip_speed(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "target_force_newtons must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+      return [False, "max_tooltip_speed must be of type float for SpeedProfile, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_finger_length(self, value: float) -> Tuple[bool, str]:
+  def validate_base_acceleration_scaling(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "finger_length must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+      return [False, "base_acceleration_scaling must be of type float for SpeedProfile, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_finger_mounting_position(self, value: float) -> Tuple[bool, str]:
+  def validate_base_velocity_scaling(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "finger_mounting_position must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+      return [False, "base_velocity_scaling must be of type float for SpeedProfile, got " + type(value).__name__]
 
     return [True, ""]
 
-  def validate_finger_offset(self, value: float) -> Tuple[bool, str]:
+  def validate_scaling_factor(self, value: float) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, float):
-      return [False, "finger_offset must be of type float for OnRobot3FG15GripperConfiguration, got " + type(value).__name__]
+      return [False, "scaling_factor must be of type float for SpeedProfile, 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_grip_detected(self.grip_detected)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_force_grip_detected(self.force_grip_detected)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_calibration_ok(self.calibration_ok)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_diameter(self.diameter)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_grip_kind(self.grip_kind)
+    is_valid, error_str = self.validate_max_joint_speeds(self.max_joint_speeds)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_angle(self.finger_angle)
+    is_valid, error_str = self.validate_max_joint_accelerations(self.max_joint_accelerations)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_force_applied_fraction(self.force_applied_fraction)
+    is_valid, error_str = self.validate_max_tooltip_speed(self.max_tooltip_speed)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_force_applied_newtons(self.force_applied_newtons)
+    is_valid, error_str = self.validate_base_acceleration_scaling(self.base_acceleration_scaling)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_target_force_newtons(self.target_force_newtons)
+    is_valid, error_str = self.validate_base_velocity_scaling(self.base_velocity_scaling)
     if not is_valid:
       raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_length(self.finger_length)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_mounting_position(self.finger_mounting_position)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_finger_offset(self.finger_offset)
+    is_valid, error_str = self.validate_scaling_factor(self.scaling_factor)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_on_robot_3_fg_15_gripper_configuration(data: object):
-  return OnRobot3FG15GripperConfiguration(
-    grip_detected=parse_bool(data["grip_detected"]) if "grip_detected" in data else None,
-    force_grip_detected=parse_bool(data["force_grip_detected"]) if "force_grip_detected" in data else None,
-    calibration_ok=parse_bool(data["calibration_ok"]) if "calibration_ok" in data else None,
-    diameter=parse_f_64(data["diameter"]) if "diameter" in data else None,
-    grip_kind=parse_on_robot_grip_kind_enum(data["grip_kind"]) if "grip_kind" in data else None,
-    finger_angle=parse_f_64(data["finger_angle"]) if "finger_angle" in data else None,
-    force_applied_fraction=parse_f_64(data["force_applied_fraction"]) if "force_applied_fraction" in data else None,
-    force_applied_newtons=parse_f_64(data["force_applied_newtons"]) if "force_applied_newtons" in data else None,
-    target_force_newtons=parse_f_64(data["target_force_newtons"]) if "target_force_newtons" in data else None,
-    finger_length=parse_f_64(data["finger_length"]) if "finger_length" in data else None,
-    finger_mounting_position=parse_f_64(data["finger_mounting_position"]) if "finger_mounting_position" in data else None,
-    finger_offset=parse_f_64(data["finger_offset"]) if "finger_offset" in data else None,
+def parse_speed_profile(data: object):
+  return SpeedProfile(
+    max_joint_speeds=parse_max_joint_speeds(data["max_joint_speeds"]) if "max_joint_speeds" in data and data.get("max_joint_speeds") is not None else None,
+    max_joint_accelerations=parse_max_joint_acclerations(data["max_joint_accelerations"]) if "max_joint_accelerations" in data and data.get("max_joint_accelerations") is not None else None,
+    max_tooltip_speed=parse_f_64(data["max_tooltip_speed"]) if "max_tooltip_speed" in data and data.get("max_tooltip_speed") is not None else None,
+    base_acceleration_scaling=parse_f_64(data["base_acceleration_scaling"]) if "base_acceleration_scaling" in data and data.get("base_acceleration_scaling") is not None else None,
+    base_velocity_scaling=parse_f_64(data["base_velocity_scaling"]) if "base_velocity_scaling" in data and data.get("base_velocity_scaling") is not None else None,
+    scaling_factor=parse_f_64(data["scaling_factor"]) if "scaling_factor" in data and data.get("scaling_factor") is not None else None,
   )
 
-def serialize_on_robot_3_fg_15_gripper_configuration(data: OnRobot3FG15GripperConfiguration) -> object:
+def serialize_speed_profile(data: SpeedProfile) -> object:
   return {
-    "grip_detected": None if data.grip_detected is None else serialize_bool(data.grip_detected),
-    "force_grip_detected": None if data.force_grip_detected is None else serialize_bool(data.force_grip_detected),
-    "calibration_ok": None if data.calibration_ok is None else serialize_bool(data.calibration_ok),
-    "diameter": None if data.diameter is None else serialize_f_64(data.diameter),
-    "grip_kind": None if data.grip_kind is None else serialize_on_robot_grip_kind_enum(data.grip_kind),
-    "finger_angle": None if data.finger_angle is None else serialize_f_64(data.finger_angle),
-    "force_applied_fraction": None if data.force_applied_fraction is None else serialize_f_64(data.force_applied_fraction),
-    "force_applied_newtons": None if data.force_applied_newtons is None else serialize_f_64(data.force_applied_newtons),
-    "target_force_newtons": None if data.target_force_newtons is None else serialize_f_64(data.target_force_newtons),
-    "finger_length": None if data.finger_length is None else serialize_f_64(data.finger_length),
-    "finger_mounting_position": None if data.finger_mounting_position is None else serialize_f_64(data.finger_mounting_position),
-    "finger_offset": None if data.finger_offset is None else serialize_f_64(data.finger_offset),
+    "max_joint_speeds": None if data.max_joint_speeds is None else serialize_max_joint_speeds(data.max_joint_speeds),
+    "max_joint_accelerations": None if data.max_joint_accelerations is None else serialize_max_joint_acclerations(data.max_joint_accelerations),
+    "max_tooltip_speed": None if data.max_tooltip_speed is None else serialize_f_64(data.max_tooltip_speed),
+    "base_acceleration_scaling": None if data.base_acceleration_scaling is None else serialize_f_64(data.base_acceleration_scaling),
+    "base_velocity_scaling": None if data.base_velocity_scaling is None else serialize_f_64(data.base_velocity_scaling),
+    "scaling_factor": None if data.scaling_factor is None else serialize_f_64(data.scaling_factor),
   }
 
 PlanesList = List[Plane]
@@ -3027,6 +3412,51 @@ def parse_planes_list(data: object) -> PlanesList:
 def serialize_planes_list(data: PlanesList) -> List[object]:
   return [serialize_plane(item) for item in data]
 
+@dataclass
+class PositionMap:
+  """The position in 3D space"""
+  jointAngles: Union[JointAnglesArray, None] = None
+  pose: Union[PositionPose, None] = None
+
+  def validate_jointAngles(self, value: JointAnglesArray) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, float) for x in value)):
+      return [False, "jointAngles must be of type JointAnglesArray for PositionMap, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_pose(self, value: PositionPose) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, PositionPose):
+      return [False, "pose must be of type PositionPose for PositionMap, 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_jointAngles(self.jointAngles)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_pose(self.pose)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_position_map(data: object):
+  return PositionMap(
+    jointAngles=parse_joint_angles_array(data["jointAngles"]) if "jointAngles" in data and data.get("jointAngles") is not None else None,
+    pose=parse_position_pose(data["pose"]) if "pose" in data and data.get("pose") is not None else None,
+  )
+
+def serialize_position_map(data: PositionMap) -> object:
+  return {
+    "jointAngles": None if data.jointAngles is None else serialize_joint_angles_array(data.jointAngles),
+    "pose": None if data.pose is None else serialize_position_pose(data.pose),
+  }
+
 @dataclass
 class Orientation:
   """Orientation of an object in 3D space"""
@@ -3062,8 +3492,8 @@ class Orientation:
 
 def parse_orientation(data: object):
   return Orientation(
-    kind=parse_orientation_kind_enum(data["kind"]) if "kind" in data else None,
-    quaternion=parse_quaternion(data["quaternion"]) if "quaternion" in data else None,
+    kind=parse_orientation_kind_enum(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    quaternion=parse_quaternion(data["quaternion"]) if "quaternion" in data and data.get("quaternion") is not None else None,
   )
 
 def serialize_orientation(data: Orientation) -> object:
@@ -3072,6 +3502,36 @@ def serialize_orientation(data: Orientation) -> object:
     "quaternion": None if data.quaternion is None else serialize_quaternion(data.quaternion),
   }
 
+@dataclass
+class RecoveryStatusResponse:
+  """Recovery status response"""
+  state: Union[RecoveryStateEnum, None] = None
+
+  def validate_state(self, value: RecoveryStateEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RecoveryStateEnum in ['Success', 'Interrupted', 'NonIdle', 'Braked', 'PlanningFailure', 'ExecutionFailure', 'ControlSystemFailure', 'EStopTriggered', 'GripperFailure', 'OutOfJointLimitsFailure', 'CollisionFailure', 'TorqueCollisionFailure', 'InBoxingPositionFailure', 'PowerBoardCheckFailure', 'MotionPlannerFailure', 'MotionPlannerFailureStartPositionCollision', 'IOFailure', 'InvalidRoutineLoadedFailure', 'InferenceFailure', 'CameraFailure', 'HaasFailure', 'BotmanHeartbeatLost', 'InternalFailure', 'TorqueLimitExceeded', 'StepPlayFailure', 'UnbrakeFailure', 'WeldFailure', 'TriggerFaultFailure']) or isinstance(value, RecoveryStateEnum)):
+      return [False, "state must be of type RecoveryStateEnum for RecoveryStatusResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_recovery_status_response(data: object):
+  return RecoveryStatusResponse(
+    state=parse_recovery_state_enum(data["state"]) if "state" in data and data.get("state") is not None else None,
+  )
+
+def serialize_recovery_status_response(data: RecoveryStatusResponse) -> object:
+  return {
+    "state": None if data.state is None else serialize_recovery_state_enum(data.state),
+  }
+
 @dataclass
 class FailureStateDetails:
   """Failure state details."""
@@ -3159,12 +3619,12 @@ class FailureStateDetails:
 
 def parse_failure_state_details(data: object):
   return FailureStateDetails(
-    failure_trace_id=parse_str(data["failure_trace_id"]) if "failure_trace_id" in data else None,
-    kind=parse_str(data["kind"]) if "kind" in data else None,
-    failed_step=parse_str(data["failed_step"]) if "failed_step" in data else None,
-    reason=parse_str(data["reason"]) if "reason" in data else None,
-    recovery_type=parse_recovery_type_enum(data["recovery_type"]) if "recovery_type" in data else None,
-    is_recoverable_with_wrist_button=parse_bool(data["is_recoverable_with_wrist_button"]) if "is_recoverable_with_wrist_button" in data else None,
+    failure_trace_id=parse_str(data["failure_trace_id"]) if "failure_trace_id" in data and data.get("failure_trace_id") is not None else None,
+    kind=parse_str(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    failed_step=parse_str(data["failed_step"]) if "failed_step" in data and data.get("failed_step") is not None else None,
+    reason=parse_str(data["reason"]) if "reason" in data and data.get("reason") is not None else None,
+    recovery_type=parse_recovery_type_enum(data["recovery_type"]) if "recovery_type" in data and data.get("recovery_type") is not None else None,
+    is_recoverable_with_wrist_button=parse_bool(data["is_recoverable_with_wrist_button"]) if "is_recoverable_with_wrist_button" in data and data.get("is_recoverable_with_wrist_button") is not None else None,
   )
 
 def serialize_failure_state_details(data: FailureStateDetails) -> object:
@@ -3199,7 +3659,7 @@ class RobotControlMode:
 
 def parse_robot_control_mode(data: object):
   return RobotControlMode(
-    kind=parse_robot_control_mode_enum(data["kind"]) if "kind" in data else None,
+    kind=parse_robot_control_mode_enum(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
   )
 
 def serialize_robot_control_mode(data: RobotControlMode) -> object:
@@ -3229,7 +3689,7 @@ class ROSControlStateResponse:
 
 def parse_ros_control_state_response(data: object):
   return ROSControlStateResponse(
-    state=parse_ros_control_state_enum(data["state"]) if "state" in data else None,
+    state=parse_ros_control_state_enum(data["state"]) if "state" in data and data.get("state") is not None else None,
   )
 
 def serialize_ros_control_state_response(data: ROSControlStateResponse) -> object:
@@ -3257,14 +3717,59 @@ class ROSControlUpdateRequest:
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_ros_control_update_request(data: object):
-  return ROSControlUpdateRequest(
-    action=parse_ros_control_state_enum(data["action"]) if "action" in data else None,
+def parse_ros_control_update_request(data: object):
+  return ROSControlUpdateRequest(
+    action=parse_ros_control_state_enum(data["action"]) if "action" in data and data.get("action") is not None else None,
+  )
+
+def serialize_ros_control_update_request(data: ROSControlUpdateRequest) -> object:
+  return {
+    "action": None if data.action is None else serialize_ros_control_state_enum(data.action),
+  }
+
+@dataclass
+class RoutineStepVariablesResponse:
+  """Step variables from the routine."""
+  variables: Union[RoutineStepVariablesData, None] = None
+  step_id_map: Union[RoutineStepVariablesIdMap, None] = None
+
+  def validate_variables(self, value: RoutineStepVariablesData) -> 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, "variables must be of type RoutineStepVariablesData for RoutineStepVariablesResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_step_id_map(self, value: RoutineStepVariablesIdMap) -> 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, "step_id_map must be of type RoutineStepVariablesIdMap for RoutineStepVariablesResponse, 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_variables(self.variables)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_step_id_map(self.step_id_map)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_routine_step_variables_response(data: object):
+  return RoutineStepVariablesResponse(
+    variables=parse_routine_step_variables_data(data["variables"]) if "variables" in data and data.get("variables") is not None else None,
+    step_id_map=parse_routine_step_variables_id_map(data["step_id_map"]) if "step_id_map" in data and data.get("step_id_map") is not None else None,
   )
 
-def serialize_ros_control_update_request(data: ROSControlUpdateRequest) -> object:
+def serialize_routine_step_variables_response(data: RoutineStepVariablesResponse) -> object:
   return {
-    "action": None if data.action is None else serialize_ros_control_state_enum(data.action),
+    "variables": None if data.variables is None else serialize_routine_step_variables_data(data.variables),
+    "step_id_map": None if data.step_id_map is None else serialize_routine_step_variables_id_map(data.step_id_map),
   }
 
 @dataclass
@@ -3289,7 +3794,7 @@ class PlayRoutineRequest:
 
 def parse_play_routine_request(data: object):
   return PlayRoutineRequest(
-    variables=parse_routine_variables_state_map(data["variables"]) if "variables" in data else None,
+    variables=parse_routine_variables_state_map(data["variables"]) if "variables" in data and data.get("variables") is not None else None,
   )
 
 def serialize_play_routine_request(data: PlayRoutineRequest) -> object:
@@ -3297,6 +3802,14 @@ def serialize_play_routine_request(data: PlayRoutineRequest) -> object:
     "variables": None if data.variables is None else serialize_routine_variables_state_map(data.variables),
   }
 
+SensorsList = List[Sensor]
+
+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]
+
 @dataclass
 class TextToSkillRequest:
   """Request to convert text to a skill."""
@@ -3332,8 +3845,8 @@ class TextToSkillRequest:
 
 def parse_text_to_skill_request(data: object):
   return TextToSkillRequest(
-    text=parse_str(data["text"]) if "text" in data else None,
-    skills=parse_skills_list(data["skills"]) if "skills" in data else None,
+    text=parse_str(data["text"]) if "text" in data and data.get("text") is not None else None,
+    skills=parse_skills_list(data["skills"]) if "skills" in data and data.get("skills") is not None else None,
   )
 
 def serialize_text_to_skill_request(data: TextToSkillRequest) -> object:
@@ -3377,8 +3890,8 @@ class StatusHealthResponse:
 
 def parse_status_health_response(data: object):
   return StatusHealthResponse(
-    health=parse_status_health_enum(data["health"]) if "health" in data else None,
-    build=parse_status_version_data(data["build"]) if "build" in data else None,
+    health=parse_status_health_enum(data["health"]) if "health" in data and data.get("health") is not None else None,
+    build=parse_status_version_data(data["build"]) if "build" in data and data.get("build") is not None else None,
   )
 
 def serialize_status_health_response(data: StatusHealthResponse) -> object:
@@ -3410,7 +3923,7 @@ class ArmPositionUpdateRequestResponseEventStreamDetails:
 
 def parse_arm_position_update_request_response_event_stream_details(data: object):
   return ArmPositionUpdateRequestResponseEventStreamDetails(
-    subscriptions=parse_arm_position_update_request_response_event_stream_subscriptions_list(data["subscriptions"]) if "subscriptions" in data else None,
+    subscriptions=parse_arm_position_update_request_response_event_stream_subscriptions_list(data["subscriptions"]) if "subscriptions" in data and data.get("subscriptions") is not None else None,
   )
 
 def serialize_arm_position_update_request_response_event_stream_details(data: ArmPositionUpdateRequestResponseEventStreamDetails) -> object:
@@ -3505,12 +4018,12 @@ class JointsStateResponse:
 
 def parse_joints_state_response(data: object):
   return JointsStateResponse(
-    J0=parse_joint_state(data["J0"]) if "J0" in data else None,
-    J1=parse_joint_state(data["J1"]) if "J1" in data else None,
-    J2=parse_joint_state(data["J2"]) if "J2" in data else None,
-    J3=parse_joint_state(data["J3"]) if "J3" in data else None,
-    J4=parse_joint_state(data["J4"]) if "J4" in data else None,
-    J5=parse_joint_state(data["J5"]) if "J5" in data else None,
+    J0=parse_joint_state(data["J0"]) if "J0" in data and data.get("J0") is not None else None,
+    J1=parse_joint_state(data["J1"]) if "J1" in data and data.get("J1") is not None else None,
+    J2=parse_joint_state(data["J2"]) if "J2" in data and data.get("J2") is not None else None,
+    J3=parse_joint_state(data["J3"]) if "J3" in data and data.get("J3") is not None else None,
+    J4=parse_joint_state(data["J4"]) if "J4" in data and data.get("J4") is not None else None,
+    J5=parse_joint_state(data["J5"]) if "J5" in data and data.get("J5") is not None else None,
   )
 
 def serialize_joints_state_response(data: JointsStateResponse) -> object:
@@ -3571,9 +4084,9 @@ class Routine:
 
 def parse_routine(data: object):
   return Routine(
-    id=parse_str(data["id"]) if "id" in data else None,
-    name=parse_str(data["name"]) if "name" in data else None,
-    environment_variables=parse_environment_variables_list(data["environment_variables"]) if "environment_variables" in data else None,
+    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,
+    environment_variables=parse_environment_variables_list(data["environment_variables"]) if "environment_variables" in data and data.get("environment_variables") is not None else None,
   )
 
 def serialize_routine(data: Routine) -> object:
@@ -3653,10 +4166,10 @@ class OnRobot2FG14GripperCommandRequest:
 
 def parse_on_robot_2_fg_14_gripper_command_request(data: object):
   return OnRobot2FG14GripperCommandRequest(
-    grip_direction=parse_linear_grip_direction_enum(data["grip_direction"]) if "grip_direction" in data else None,
-    target_force=parse_force_unit(data["target_force"]) if "target_force" in data else None,
-    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data else None,
-    control_kind=parse_on_robot_2_fg_14_control_kind_enum(data["control_kind"]) if "control_kind" in data else None,
+    grip_direction=parse_linear_grip_direction_enum(data["grip_direction"]) if "grip_direction" in data and data.get("grip_direction") is not None else None,
+    target_force=parse_force_unit(data["target_force"]) if "target_force" in data and data.get("target_force") is not None else None,
+    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data and data.get("target_grip_width") is not None else None,
+    control_kind=parse_on_robot_2_fg_14_control_kind_enum(data["control_kind"]) if "control_kind" in data and data.get("control_kind") is not None else None,
   )
 
 def serialize_on_robot_2_fg_14_gripper_command_request(data: OnRobot2FG14GripperCommandRequest) -> object:
@@ -3729,10 +4242,10 @@ class OnRobot2FG7GripperCommandRequest:
 
 def parse_on_robot_2_fg_7_gripper_command_request(data: object):
   return OnRobot2FG7GripperCommandRequest(
-    grip_direction=parse_linear_grip_direction_enum(data["grip_direction"]) if "grip_direction" in data else None,
-    target_force=parse_force_unit(data["target_force"]) if "target_force" in data else None,
-    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data else None,
-    control_kind=parse_on_robot_2_fg_7_control_kind_enum(data["control_kind"]) if "control_kind" in data else None,
+    grip_direction=parse_linear_grip_direction_enum(data["grip_direction"]) if "grip_direction" in data and data.get("grip_direction") is not None else None,
+    target_force=parse_force_unit(data["target_force"]) if "target_force" in data and data.get("target_force") is not None else None,
+    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data and data.get("target_grip_width") is not None else None,
+    control_kind=parse_on_robot_2_fg_7_control_kind_enum(data["control_kind"]) if "control_kind" in data and data.get("control_kind") is not None else None,
   )
 
 def serialize_on_robot_2_fg_7_gripper_command_request(data: OnRobot2FG7GripperCommandRequest) -> object:
@@ -3805,10 +4318,10 @@ class OnRobot3FG15GripperCommandRequest:
 
 def parse_on_robot_3_fg_15_gripper_command_request(data: object):
   return OnRobot3FG15GripperCommandRequest(
-    grip_direction=parse_linear_grip_direction_enum(data["grip_direction"]) if "grip_direction" in data else None,
-    target_force=parse_force_unit(data["target_force"]) if "target_force" in data else None,
-    target_grip_diameter=parse_linear_unit(data["target_grip_diameter"]) if "target_grip_diameter" in data else None,
-    control_kind=parse_on_robot_3_fg_15_control_kind_enum(data["control_kind"]) if "control_kind" in data else None,
+    grip_direction=parse_linear_grip_direction_enum(data["grip_direction"]) if "grip_direction" in data and data.get("grip_direction") is not None else None,
+    target_force=parse_force_unit(data["target_force"]) if "target_force" in data and data.get("target_force") is not None else None,
+    target_grip_diameter=parse_linear_unit(data["target_grip_diameter"]) if "target_grip_diameter" in data and data.get("target_grip_diameter") is not None else None,
+    control_kind=parse_on_robot_3_fg_15_control_kind_enum(data["control_kind"]) if "control_kind" in data and data.get("control_kind") is not None else None,
   )
 
 def serialize_on_robot_3_fg_15_gripper_command_request(data: OnRobot3FG15GripperCommandRequest) -> object:
@@ -3855,8 +4368,8 @@ class SchunkEGxGripperCommandRequest:
 
 def parse_schunk_e_gx_gripper_command_request(data: object):
   return SchunkEGxGripperCommandRequest(
-    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data else None,
-    control_kind=parse_schunk_e_gx_control_kind_enum(data["control_kind"]) if "control_kind" in data else None,
+    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data and data.get("target_grip_width") is not None else None,
+    control_kind=parse_schunk_e_gx_control_kind_enum(data["control_kind"]) if "control_kind" in data and data.get("control_kind") is not None else None,
   )
 
 def serialize_schunk_e_gx_gripper_command_request(data: SchunkEGxGripperCommandRequest) -> object:
@@ -3865,141 +4378,6 @@ def serialize_schunk_e_gx_gripper_command_request(data: SchunkEGxGripperCommandR
     "control_kind": serialize_schunk_e_gx_control_kind_enum(data.control_kind),
   }
 
-@dataclass
-class GripperConfiguration:
-  """Configuration of gripper, also known as End Effector"""
-  kind: Union[GripperKindEnum, None] = None
-  onrobot_2fg7: Union[OnRobot2FG7GripperConfiguration, None] = None
-  onrobot_2fg14: Union[OnRobot2FG14GripperConfiguration, None] = None
-  onrobot_3fg15: Union[OnRobot3FG15GripperConfiguration, None] = None
-  onrobot_screwdriver: Union[OnRobotScrewdriverConfiguration, None] = None
-  dh_ag: Union[DHAGGripperConfiguration, None] = None
-  dh_pgc: Union[DHPGCGripperConfiguration, None] = None
-  dh_cgi: Union[DHCGIGripperConfiguration, None] = None
-
-  def validate_kind(self, value: GripperKindEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [False, "kind is required for GripperConfiguration"]
-
-    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'onrobot_screwdriver', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
-      return [False, "kind must be of type GripperKindEnum for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_onrobot_2fg7(self, value: OnRobot2FG7GripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, OnRobot2FG7GripperConfiguration):
-      return [False, "onrobot_2fg7 must be of type OnRobot2FG7GripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_onrobot_2fg14(self, value: OnRobot2FG14GripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, OnRobot2FG14GripperConfiguration):
-      return [False, "onrobot_2fg14 must be of type OnRobot2FG14GripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_onrobot_3fg15(self, value: OnRobot3FG15GripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, OnRobot3FG15GripperConfiguration):
-      return [False, "onrobot_3fg15 must be of type OnRobot3FG15GripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_onrobot_screwdriver(self, value: OnRobotScrewdriverConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, OnRobotScrewdriverConfiguration):
-      return [False, "onrobot_screwdriver must be of type OnRobotScrewdriverConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_dh_ag(self, value: DHAGGripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, DHAGGripperConfiguration):
-      return [False, "dh_ag must be of type DHAGGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_dh_pgc(self, value: DHPGCGripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, DHPGCGripperConfiguration):
-      return [False, "dh_pgc must be of type DHPGCGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_dh_cgi(self, value: DHCGIGripperConfiguration) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, DHCGIGripperConfiguration):
-      return [False, "dh_cgi must be of type DHCGIGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_kind(self.kind)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_onrobot_2fg7(self.onrobot_2fg7)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_onrobot_2fg14(self.onrobot_2fg14)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_onrobot_3fg15(self.onrobot_3fg15)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_onrobot_screwdriver(self.onrobot_screwdriver)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_ag(self.dh_ag)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_pgc(self.dh_pgc)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_dh_cgi(self.dh_cgi)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_gripper_configuration(data: object):
-  return GripperConfiguration(
-    kind=parse_gripper_kind_enum(data["kind"]) if "kind" in data else None,
-    onrobot_2fg7=parse_on_robot_2_fg_7_gripper_configuration(data["onrobot_2fg7"]) if "onrobot_2fg7" in data else None,
-    onrobot_2fg14=parse_on_robot_2_fg_14_gripper_configuration(data["onrobot_2fg14"]) if "onrobot_2fg14" in data else None,
-    onrobot_3fg15=parse_on_robot_3_fg_15_gripper_configuration(data["onrobot_3fg15"]) if "onrobot_3fg15" in data else None,
-    onrobot_screwdriver=parse_on_robot_screwdriver_configuration(data["onrobot_screwdriver"]) if "onrobot_screwdriver" in data else None,
-    dh_ag=parse_dhag_gripper_configuration(data["dh_ag"]) if "dh_ag" in data else None,
-    dh_pgc=parse_dhpgc_gripper_configuration(data["dh_pgc"]) if "dh_pgc" in data else None,
-    dh_cgi=parse_dhcgi_gripper_configuration(data["dh_cgi"]) if "dh_cgi" in data else None,
-  )
-
-def serialize_gripper_configuration(data: GripperConfiguration) -> object:
-  return {
-    "kind": serialize_gripper_kind_enum(data.kind),
-    "onrobot_2fg7": None if data.onrobot_2fg7 is None else serialize_on_robot_2_fg_7_gripper_configuration(data.onrobot_2fg7),
-    "onrobot_2fg14": None if data.onrobot_2fg14 is None else serialize_on_robot_2_fg_14_gripper_configuration(data.onrobot_2fg14),
-    "onrobot_3fg15": None if data.onrobot_3fg15 is None else serialize_on_robot_3_fg_15_gripper_configuration(data.onrobot_3fg15),
-    "onrobot_screwdriver": None if data.onrobot_screwdriver is None else serialize_on_robot_screwdriver_configuration(data.onrobot_screwdriver),
-    "dh_ag": None if data.dh_ag is None else serialize_dhag_gripper_configuration(data.dh_ag),
-    "dh_pgc": None if data.dh_pgc is None else serialize_dhpgc_gripper_configuration(data.dh_pgc),
-    "dh_cgi": None if data.dh_cgi is None else serialize_dhcgi_gripper_configuration(data.dh_cgi),
-  }
-
 @dataclass
 class PlanesPaginatedResponse:
   """Paginated response containing plane data"""
@@ -4035,8 +4413,8 @@ class PlanesPaginatedResponse:
 
 def parse_planes_paginated_response(data: object):
   return PlanesPaginatedResponse(
-    items=parse_planes_list(data["items"]) if "items" in data else None,
-    pagination=parse_pagination(data["pagination"]) if "pagination" in data else None,
+    items=parse_planes_list(data["items"]) if "items" in data and data.get("items") is not None else None,
+    pagination=parse_pagination(data["pagination"]) if "pagination" in data and data.get("pagination") is not None else None,
   )
 
 def serialize_planes_paginated_response(data: PlanesPaginatedResponse) -> object:
@@ -4045,6 +4423,14 @@ def serialize_planes_paginated_response(data: PlanesPaginatedResponse) -> object
     "pagination": None if data.pagination is None else serialize_pagination(data.pagination),
   }
 
+SpacePositionsMap = List[PositionMap]
+
+def parse_space_positions_map(data: object) -> SpacePositionsMap:
+  return [parse_position_map(item) for item in data]
+
+def serialize_space_positions_map(data: SpacePositionsMap) -> List[object]:
+  return [serialize_position_map(item) for item in data]
+
 @dataclass
 class PositionAndOrientation:
   """Position of the arm tooltip"""
@@ -4119,11 +4505,11 @@ class PositionAndOrientation:
 
 def parse_position_and_orientation(data: object):
   return PositionAndOrientation(
-    axis_alignment=parse_str(data["axis_alignment"]) if "axis_alignment" in data else None,
-    reference_frame=parse_str(data["reference_frame"]) if "reference_frame" in data else None,
-    local_accuracy_calibration=parse_str(data["local_accuracy_calibration"]) if "local_accuracy_calibration" in data else None,
-    position=parse_position(data["position"]) if "position" in data else None,
-    orientation=parse_orientation(data["orientation"]) if "orientation" in data else None,
+    axis_alignment=parse_str(data["axis_alignment"]) if "axis_alignment" in data and data.get("axis_alignment") is not None else None,
+    reference_frame=parse_str(data["reference_frame"]) if "reference_frame" in data and data.get("reference_frame") is not None else None,
+    local_accuracy_calibration=parse_str(data["local_accuracy_calibration"]) if "local_accuracy_calibration" in data and data.get("local_accuracy_calibration") is not None else None,
+    position=parse_position(data["position"]) if "position" in data and data.get("position") is not None else None,
+    orientation=parse_orientation(data["orientation"]) if "orientation" in data and data.get("orientation") is not None else None,
   )
 
 def serialize_position_and_orientation(data: PositionAndOrientation) -> object:
@@ -4138,19 +4524,9 @@ def serialize_position_and_orientation(data: PositionAndOrientation) -> object:
 @dataclass
 class FailureStateResponse:
   """Failure state response informs user of how and whether the robot may be recovered."""
-  status: Union[RobotStatusEnum, None] = None
   failed: Union[bool, None] = None
   failure: Union[FailureStateDetails, None] = None
 
-  def validate_status(self, value: RobotStatusEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not ((isinstance(value, str) and RobotStatusEnum in ['Idle', 'RunningAdHocCommand', 'RoutineRunning', 'Antigravity', 'AntigravitySlow', 'Failure', 'Recovering']) or isinstance(value, RobotStatusEnum)):
-      return [False, "status must be of type RobotStatusEnum for FailureStateResponse, got " + type(value).__name__]
-
-    return [True, ""]
-
   def validate_failed(self, value: bool) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
@@ -4171,9 +4547,6 @@ class FailureStateResponse:
 
   def __post_init__(self):
     # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_status(self.status)
-    if not is_valid:
-      raise TypeError(error_str)
     is_valid, error_str = self.validate_failed(self.failed)
     if not is_valid:
       raise TypeError(error_str)
@@ -4183,18 +4556,46 @@ class FailureStateResponse:
 
 def parse_failure_state_response(data: object):
   return FailureStateResponse(
-    status=parse_robot_status_enum(data["status"]) if "status" in data else None,
-    failed=parse_bool(data["failed"]) if "failed" in data else None,
-    failure=parse_failure_state_details(data["failure"]) if "failure" in data else None,
+    failed=parse_bool(data["failed"]) if "failed" in data and data.get("failed") is not None else None,
+    failure=parse_failure_state_details(data["failure"]) if "failure" in data and data.get("failure") is not None else None,
   )
 
 def serialize_failure_state_response(data: FailureStateResponse) -> object:
   return {
-    "status": None if data.status is None else serialize_robot_status_enum(data.status),
     "failed": None if data.failed is None else serialize_bool(data.failed),
     "failure": None if data.failure is None else serialize_failure_state_details(data.failure),
   }
 
+@dataclass
+class SensorsConfiguration:
+  """Configuration of all sensors defined in custom equipment"""
+  sensors: Union[SensorsList, None] = None
+
+  def validate_sensors(self, value: SensorsList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, Sensor) for x in value)):
+      return [False, "sensors must be of type SensorsList for SensorsConfiguration, 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_sensors(self.sensors)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_sensors_configuration(data: object):
+  return SensorsConfiguration(
+    sensors=parse_sensors_list(data["sensors"]) if "sensors" in data and data.get("sensors") is not None else None,
+  )
+
+def serialize_sensors_configuration(data: SensorsConfiguration) -> object:
+  return {
+    "sensors": None if data.sensors is None else serialize_sensors_list(data.sensors),
+  }
+
 @dataclass
 class ArmPositionUpdateRequestResponseFormat:
   """Specify how the response should be sent
@@ -4231,8 +4632,8 @@ class ArmPositionUpdateRequestResponseFormat:
 
 def parse_arm_position_update_request_response_format(data: object):
   return ArmPositionUpdateRequestResponseFormat(
-    kind=parse_arm_position_update_request_response_kind_enum(data["kind"]) if "kind" in data else None,
-    event_stream=parse_arm_position_update_request_response_event_stream_details(data["event_stream"]) if "event_stream" in data else None,
+    kind=parse_arm_position_update_request_response_kind_enum(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    event_stream=parse_arm_position_update_request_response_event_stream_details(data["event_stream"]) if "event_stream" in data and data.get("event_stream") is not None else None,
   )
 
 def serialize_arm_position_update_request_response_format(data: ArmPositionUpdateRequestResponseFormat) -> object:
@@ -4266,7 +4667,7 @@ class GripperCommandRequest:
     if value is None:
       return [False, "kind is required for GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'onrobot_screwdriver', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -4363,14 +4764,14 @@ class GripperCommandRequest:
 
 def parse_gripper_command_request(data: object):
   return GripperCommandRequest(
-    kind=parse_gripper_kind_enum(data["kind"]) if "kind" in data else None,
-    onrobot_2fg7=parse_on_robot_2_fg_7_gripper_command_request(data["onrobot_2fg7"]) if "onrobot_2fg7" in data else None,
-    onrobot_2fg14=parse_on_robot_2_fg_14_gripper_command_request(data["onrobot_2fg14"]) if "onrobot_2fg14" in data else None,
-    onrobot_3fg15=parse_on_robot_3_fg_15_gripper_command_request(data["onrobot_3fg15"]) if "onrobot_3fg15" in data else None,
-    dh_ag=parse_dhag_gripper_command_request(data["dh_ag"]) if "dh_ag" in data else None,
-    dh_pgc=parse_dhpgc_gripper_command_request(data["dh_pgc"]) if "dh_pgc" in data else None,
-    dh_cgi=parse_dhcgi_gripper_command_request(data["dh_cgi"]) if "dh_cgi" in data else None,
-    schunk_egx=parse_schunk_e_gx_gripper_command_request(data["schunk_egx"]) if "schunk_egx" in data else None,
+    kind=parse_gripper_kind_enum(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    onrobot_2fg7=parse_on_robot_2_fg_7_gripper_command_request(data["onrobot_2fg7"]) if "onrobot_2fg7" in data and data.get("onrobot_2fg7") is not None else None,
+    onrobot_2fg14=parse_on_robot_2_fg_14_gripper_command_request(data["onrobot_2fg14"]) if "onrobot_2fg14" in data and data.get("onrobot_2fg14") is not None else None,
+    onrobot_3fg15=parse_on_robot_3_fg_15_gripper_command_request(data["onrobot_3fg15"]) if "onrobot_3fg15" in data and data.get("onrobot_3fg15") is not None else None,
+    dh_ag=parse_dhag_gripper_command_request(data["dh_ag"]) if "dh_ag" in data and data.get("dh_ag") is not None else None,
+    dh_pgc=parse_dhpgc_gripper_command_request(data["dh_pgc"]) if "dh_pgc" in data and data.get("dh_pgc") is not None else None,
+    dh_cgi=parse_dhcgi_gripper_command_request(data["dh_cgi"]) if "dh_cgi" in data and data.get("dh_cgi") is not None else None,
+    schunk_egx=parse_schunk_e_gx_gripper_command_request(data["schunk_egx"]) if "schunk_egx" in data and data.get("schunk_egx") is not None else None,
   )
 
 def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
@@ -4385,6 +4786,111 @@ def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
     "schunk_egx": None if data.schunk_egx is None else serialize_schunk_e_gx_gripper_command_request(data.schunk_egx),
   }
 
+@dataclass
+class Space:
+  """Space in 3D space"""
+  id: Union[str, None] = None
+  kind: Union[str, None] = None
+  name: Union[str, None] = None
+  description: Union[str, None] = None
+  isGlobal: Union[bool, None] = None
+  positions: Union[SpacePositionsMap, 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 Space, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_kind(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "kind must be of type str for Space, 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 Space, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_description(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "description must be of type str for Space, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_isGlobal(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "isGlobal must be of type bool for Space, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_positions(self, value: SpacePositionsMap) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, PositionMap) for x in value)):
+      return [False, "positions must be of type SpacePositionsMap for Space, 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_kind(self.kind)
+    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_description(self.description)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_isGlobal(self.isGlobal)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_positions(self.positions)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_space(data: object):
+  return Space(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    kind=parse_str(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
+    description=parse_str(data["description"]) if "description" in data and data.get("description") is not None else None,
+    isGlobal=parse_bool(data["isGlobal"]) if "isGlobal" in data and data.get("isGlobal") is not None else None,
+    positions=parse_space_positions_map(data["positions"]) if "positions" in data and data.get("positions") is not None else None,
+  )
+
+def serialize_space(data: Space) -> object:
+  return {
+    "id": None if data.id is None else serialize_str(data.id),
+    "kind": None if data.kind is None else serialize_str(data.kind),
+    "name": None if data.name is None else serialize_str(data.name),
+    "description": None if data.description is None else serialize_str(data.description),
+    "isGlobal": None if data.isGlobal is None else serialize_bool(data.isGlobal),
+    "positions": None if data.positions is None else serialize_space_positions_map(data.positions),
+  }
+
 @dataclass
 class CombinedArmPosition:
   """Combined tooltip position and joint rotations defining the arm's position"""
@@ -4420,8 +4926,8 @@ class CombinedArmPosition:
 
 def parse_combined_arm_position(data: object):
   return CombinedArmPosition(
-    joint_rotations=parse_joint_rotations(data["joint_rotations"]) if "joint_rotations" in data else None,
-    tooltip_position=parse_position_and_orientation(data["tooltip_position"]) if "tooltip_position" in data else None,
+    joint_rotations=parse_joint_rotations(data["joint_rotations"]) if "joint_rotations" in data and data.get("joint_rotations") is not None else None,
+    tooltip_position=parse_position_and_orientation(data["tooltip_position"]) if "tooltip_position" in data and data.get("tooltip_position") is not None else None,
   )
 
 def serialize_combined_arm_position(data: CombinedArmPosition) -> object:
@@ -4473,8 +4979,8 @@ class RoutinesPaginatedResponse:
 
 def parse_routines_paginated_response(data: object):
   return RoutinesPaginatedResponse(
-    items=parse_routines_list(data["items"]) if "items" in data else None,
-    pagination=parse_pagination(data["pagination"]) if "pagination" in data else None,
+    items=parse_routines_list(data["items"]) if "items" in data and data.get("items") is not None else None,
+    pagination=parse_pagination(data["pagination"]) if "pagination" in data and data.get("pagination") is not None else None,
   )
 
 def serialize_routines_paginated_response(data: RoutinesPaginatedResponse) -> object:
@@ -4483,6 +4989,14 @@ def serialize_routines_paginated_response(data: RoutinesPaginatedResponse) -> ob
     "pagination": None if data.pagination is None else serialize_pagination(data.pagination),
   }
 
+SpacesList = List[Space]
+
+def parse_spaces_list(data: object) -> SpacesList:
+  return [parse_space(item) for item in data]
+
+def serialize_spaces_list(data: SpacesList) -> List[object]:
+  return [serialize_space(item) for item in data]
+
 @dataclass
 class ArmPositionUpdateEvent:
   """Event emitted by the move robot API"""
@@ -4544,10 +5058,10 @@ class ArmPositionUpdateEvent:
 
 def parse_arm_position_update_event(data: object):
   return ArmPositionUpdateEvent(
-    kind=parse_arm_position_update_kind_enum(data["kind"]) if "kind" in data else None,
-    failure=parse_arm_position_update_failure_event(data["failure"]) if "failure" in data else None,
-    canceled=parse_arm_position_update_canceled_event(data["canceled"]) if "canceled" in data else None,
-    position=parse_combined_arm_position(data["position"]) if "position" in data else None,
+    kind=parse_arm_position_update_kind_enum(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    failure=parse_arm_position_update_failure_event(data["failure"]) if "failure" in data and data.get("failure") is not None else None,
+    canceled=parse_arm_position_update_canceled_event(data["canceled"]) if "canceled" in data and data.get("canceled") is not None else None,
+    position=parse_combined_arm_position(data["position"]) if "position" in data and data.get("position") is not None else None,
   )
 
 def serialize_arm_position_update_event(data: ArmPositionUpdateEvent) -> object:
@@ -4566,6 +5080,8 @@ class ArmPositionUpdateRequest:
   tooltip_position: Union[PositionAndOrientation, None] = None
   joint_rotations: Union[ArmJointRotationsList, None] = None
   joint_rotation: Union[ArmJointRotations, None] = None
+  movement_kind: Union[MovementKindEnum, None] = None
+  speed_profile: Union[SpeedProfile, None] = None
   response: Union[ArmPositionUpdateRequestResponseFormat, None] = None
 
   def validate_kind(self, value: ArmPositionUpdateRequestKindEnum) -> Tuple[bool, str]:
@@ -4613,6 +5129,24 @@ class ArmPositionUpdateRequest:
 
     return [True, ""]
 
+  def validate_movement_kind(self, value: MovementKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and MovementKindEnum in ['joint', 'line']) or isinstance(value, MovementKindEnum)):
+      return [False, "movement_kind must be of type MovementKindEnum for ArmPositionUpdateRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_speed_profile(self, value: SpeedProfile) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, SpeedProfile):
+      return [False, "speed_profile must be of type SpeedProfile for ArmPositionUpdateRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
   def validate_response(self, value: ArmPositionUpdateRequestResponseFormat) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
@@ -4637,6 +5171,12 @@ class ArmPositionUpdateRequest:
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_joint_rotation(self.joint_rotation)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_movement_kind(self.movement_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_speed_profile(self.speed_profile)
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_response(self.response)
@@ -4645,12 +5185,14 @@ class ArmPositionUpdateRequest:
 
 def parse_arm_position_update_request(data: object):
   return ArmPositionUpdateRequest(
-    kind=parse_arm_position_update_request_kind_enum(data["kind"]) if "kind" in data else None,
-    tooltip_positions=parse_position_and_orientation_list(data["tooltip_positions"]) if "tooltip_positions" in data else None,
-    tooltip_position=parse_position_and_orientation(data["tooltip_position"]) if "tooltip_position" in data else None,
-    joint_rotations=parse_arm_joint_rotations_list(data["joint_rotations"]) if "joint_rotations" in data else None,
-    joint_rotation=parse_arm_joint_rotations(data["joint_rotation"]) if "joint_rotation" in data else None,
-    response=parse_arm_position_update_request_response_format(data["response"]) if "response" in data else None,
+    kind=parse_arm_position_update_request_kind_enum(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    tooltip_positions=parse_position_and_orientation_list(data["tooltip_positions"]) if "tooltip_positions" in data and data.get("tooltip_positions") is not None else None,
+    tooltip_position=parse_position_and_orientation(data["tooltip_position"]) if "tooltip_position" in data and data.get("tooltip_position") is not None else None,
+    joint_rotations=parse_arm_joint_rotations_list(data["joint_rotations"]) if "joint_rotations" in data and data.get("joint_rotations") is not None else None,
+    joint_rotation=parse_arm_joint_rotations(data["joint_rotation"]) if "joint_rotation" in data and data.get("joint_rotation") is not None else None,
+    movement_kind=parse_movement_kind_enum(data["movement_kind"]) if "movement_kind" in data and data.get("movement_kind") is not None else None,
+    speed_profile=parse_speed_profile(data["speed_profile"]) if "speed_profile" in data and data.get("speed_profile") is not None else None,
+    response=parse_arm_position_update_request_response_format(data["response"]) if "response" in data and data.get("response") is not None else None,
   )
 
 def serialize_arm_position_update_request(data: ArmPositionUpdateRequest) -> object:
@@ -4660,9 +5202,41 @@ def serialize_arm_position_update_request(data: ArmPositionUpdateRequest) -> obj
     "tooltip_position": None if data.tooltip_position is None else serialize_position_and_orientation(data.tooltip_position),
     "joint_rotations": None if data.joint_rotations is None else serialize_arm_joint_rotations_list(data.joint_rotations),
     "joint_rotation": None if data.joint_rotation is None else serialize_arm_joint_rotations(data.joint_rotation),
+    "movement_kind": None if data.movement_kind is None else serialize_movement_kind_enum(data.movement_kind),
+    "speed_profile": None if data.speed_profile is None else serialize_speed_profile(data.speed_profile),
     "response": None if data.response is None else serialize_arm_position_update_request_response_format(data.response),
   }
 
+@dataclass
+class SpacesPaginatedResponse:
+  """Paginated response containing space data"""
+  items: Union[SpacesList, None] = None
+
+  def validate_items(self, value: SpacesList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, Space) for x in value)):
+      return [False, "items must be of type SpacesList for SpacesPaginatedResponse, 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_items(self.items)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_spaces_paginated_response(data: object):
+  return SpacesPaginatedResponse(
+    items=parse_spaces_list(data["items"]) if "items" in data and data.get("items") is not None else None,
+  )
+
+def serialize_spaces_paginated_response(data: SpacesPaginatedResponse) -> object:
+  return {
+    "items": None if data.items is None else serialize_spaces_list(data.items),
+  }
+
 ArmPositionUpdateEventStream = List[ArmPositionUpdateEvent]
 
 def parse_arm_position_update_event_stream(data: object) -> ArmPositionUpdateEventStream: