placo 0.9.6__0-cp313-cp313-macosx_11_0_arm64.whl → 0.9.8__0-cp313-cp313-macosx_11_0_arm64.whl

cmeel.prefix/lib/python3.13/site-packages/placo.pyi

@@ -123,13 +123,9 @@ class AvoidSelfCollisionsDynamicsConstraint:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -137,22 +133,14 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  self_collisions_margin: any
+  self_collisions_margin: float # double
   """
-  
-None( (placo.AvoidSelfCollisionsDynamicsConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::AvoidSelfCollisionsConstraint {lvalue})
+  Margin for self collisions [m].
   """
 
-  self_collisions_trigger: any
+  self_collisions_trigger: float # double
   """
-  
-None( (placo.AvoidSelfCollisionsDynamicsConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::AvoidSelfCollisionsConstraint {lvalue})
+  Distance that triggers the constraint [m].
   """
 
 
@@ -179,13 +167,9 @@ class AvoidSelfCollisionsKinematicsConstraint:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -193,33 +177,21 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  self_collisions_margin: any
+  self_collisions_margin: float # double
   """
-  
-None( (placo.AvoidSelfCollisionsKinematicsConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::AvoidSelfCollisionsConstraint {lvalue})
+  Margin for self collisions [m].
   """
 
-  self_collisions_trigger: any
+  self_collisions_trigger: float # double
   """
-  
-None( (placo.AvoidSelfCollisionsKinematicsConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::AvoidSelfCollisionsConstraint {lvalue})
+  Distance that triggers the constraint [m].
   """
 
 
 class AxisAlignTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -230,22 +202,14 @@ None( (placo.Task)arg1) -> object :
   ) -> any:
     ...
 
-  axis_frame: any
+  axis_frame: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.AxisAlignTask)arg1) -> numpy.ndarray :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> None(placo::kinematics::AxisAlignTask)
+  Axis in the frame.
   """
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -281,22 +245,14 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  frame_index: any
+  frame_index: any # pinocchio::FrameIndex
   """
-  
-None( (placo.AxisAlignTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::AxisAlignTask {lvalue})
+  Target frame.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -304,13 +260,9 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  targetAxis_world: any
+  targetAxis_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.AxisAlignTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::kinematics::AxisAlignTask {lvalue})
+  Target axis in the world.
   """
 
   def update(
@@ -323,22 +275,14 @@ None( (placo.AxisAlignTask)arg1) -> object :
 
 
 class AxisesMask:
-  R_custom_world: any
+  R_custom_world: numpy.ndarray # Eigen::Matrix3d
   """
-  
-None( (placo.AxisesMask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::tools::AxisesMask {lvalue})
+  Rotation from world to custom rotation (provided by the user)
   """
 
-  R_local_world: any
+  R_local_world: numpy.ndarray # Eigen::Matrix3d
   """
-  
-None( (placo.AxisesMask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::tools::AxisesMask {lvalue})
+  Rotation from world to local frame (provided by task)
   """
 
   def __init__(
@@ -373,22 +317,14 @@ None( (placo.AxisesMask)arg1) -> object :
 
 
 class CentroidalMomentumTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
-  L_world: any
+  L_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.CentroidalMomentumTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::kinematics::CentroidalMomentumTask {lvalue})
+  Target centroidal angular momentum in the world.
   """
 
   def __init__(
@@ -400,13 +336,9 @@ None( (placo.CentroidalMomentumTask)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -442,22 +374,14 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.CentroidalMomentumTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::kinematics::CentroidalMomentumTask {lvalue})
+  Axises mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -504,49 +428,29 @@ class CoMPolygonConstraint:
     """
     ...
 
-  dcm: any
+  dcm: bool # bool
   """
-  
-None( (placo.CoMPolygonConstraint)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::kinematics::CoMPolygonConstraint {lvalue})
+  If set to true, the DCM will be used instead of the CoM.
   """
 
-  margin: any
+  margin: float # double
   """
-  
-None( (placo.CoMPolygonConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::CoMPolygonConstraint {lvalue})
+  Margin for the polygon constraint (minimum distance between the CoM and the polygon)
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
-  omega: any
+  omega: float # double
   """
-  
-None( (placo.CoMPolygonConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::CoMPolygonConstraint {lvalue})
+  If DCM mode is enabled, the constraint will be applied on the DCM instead of the CoM with the following omega (sqrt(g / h))
   """
 
-  polygon: any
+  polygon: list[numpy.ndarray] # std::vector< Eigen::Vector2d >
   """
-  
-None( (placo.CoMPolygonConstraint)arg1) -> placo.vector_Vector2d :
-
-    C++ signature :
-        std::__1::vector<Eigen::Matrix<double, 2, 1, 0, 2, 1>, std::__1::allocator<Eigen::Matrix<double, 2, 1, 0, 2, 1>>> {lvalue} None(placo::kinematics::CoMPolygonConstraint {lvalue})
+  Clockwise polygon.
   """
 
   priority: str
@@ -556,13 +460,9 @@ None( (placo.CoMPolygonConstraint)arg1) -> placo.vector_Vector2d :
 
 
 class CoMTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -574,13 +474,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -616,22 +512,14 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.CoMTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::kinematics::CoMTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -639,13 +527,9 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  target_world: any
+  target_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.CoMTask)arg1) -> numpy.ndarray :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> None(placo::kinematics::CoMTask)
+  Target for the CoM in the world.
   """
 
   def update(
@@ -663,22 +547,14 @@ class Collision:
   ) -> None:
     ...
 
-  bodyA: any
+  bodyA: str # std::string
   """
-  
-None( (placo.Collision)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::model::RobotWrapper::Collision {lvalue})
+  Name of the body A.
   """
 
-  bodyB: any
+  bodyB: str # std::string
   """
-  
-None( (placo.Collision)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::model::RobotWrapper::Collision {lvalue})
+  Name of the body B.
   """
 
   def get_contact(
@@ -687,51 +563,31 @@ None( (placo.Collision)arg1) -> str :
   ) -> numpy.ndarray:
     ...
 
-  objA: any
+  objA: int # int
   """
-  
-None( (placo.Collision)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::model::RobotWrapper::Collision {lvalue})
+  Index of object A in the collision geometry.
   """
 
-  objB: any
+  objB: int # int
   """
-  
-None( (placo.Collision)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::model::RobotWrapper::Collision {lvalue})
+  Index of object B in the collision geometry.
   """
 
-  parentA: any
+  parentA: any # pinocchio::JointIndex
   """
-  
-None( (placo.Collision)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::model::RobotWrapper::Collision {lvalue})
+  The joint parent of body A.
   """
 
-  parentB: any
+  parentB: any # pinocchio::JointIndex
   """
-  
-None( (placo.Collision)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::model::RobotWrapper::Collision {lvalue})
+  The joint parent of body B.
   """
 
 
 class ConeConstraint:
-  N: any
+  N: int # int
   """
-  
-None( (placo.ConeConstraint)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::kinematics::ConeConstraint {lvalue})
+  Number of slices used to discretize the cone.
   """
 
   def __init__(
@@ -751,13 +607,9 @@ None( (placo.ConeConstraint)arg1) -> int :
     """
     ...
 
-  angle_max: any
+  angle_max: float # double
   """
-  
-None( (placo.ConeConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::ConeConstraint {lvalue})
+  Maximum angle allowable by the cone constraint (between z-axis of frame_a and frame_b)
   """
 
   def configure(
@@ -777,13 +629,9 @@ None( (placo.ConeConstraint)arg1) -> float :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -791,13 +639,9 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  range: any
+  range: float # double
   """
-  
-None( (placo.ConeConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::ConeConstraint {lvalue})
+  Range of the cone discretization (in radians). The cone is discretized in [-range, range] around the current orientation.
   """
 
 
@@ -807,58 +651,34 @@ class Contact:
   ) -> any:
     ...
 
-  active: any
+  active: bool # bool
   """
-  
-None( (placo.Contact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact {lvalue})
+  true if the contact is active (ignored by the solver else, this allow to enable/disable a contact without removing it from the solver)
   """
 
-  mu: any
+  mu: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Coefficient of friction (if relevant)
   """
 
-  weight_forces: any
+  weight_forces: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of forces for the optimization (if relevant)
   """
 
-  weight_moments: any
+  weight_moments: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of moments for optimization (if relevant)
   """
 
-  weight_tangentials: any
+  weight_tangentials: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Extra cost for tangential forces.
   """
 
-  wrench: any
+  wrench: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Contact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::Contact {lvalue})
+  Wrench populated after the DynamicsSolver::solve call.
   """
 
 
@@ -873,31 +693,19 @@ class Contact6D:
     """
     ...
 
-  active: any
+  active: bool # bool
   """
-  
-None( (placo.Contact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact {lvalue})
+  true if the contact is active (ignored by the solver else, this allow to enable/disable a contact without removing it from the solver)
   """
 
-  length: any
+  length: float # double
   """
-  
-None( (placo.Contact6D)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact6D {lvalue})
+  Rectangular contact length along local x-axis.
   """
 
-  mu: any
+  mu: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Coefficient of friction (if relevant)
   """
 
   def orientation_task(
@@ -910,58 +718,34 @@ None( (placo.Contact)arg1) -> float :
   ) -> DynamicsPositionTask:
     ...
 
-  unilateral: any
+  unilateral: bool # bool
   """
-  
-None( (placo.Contact6D)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact6D {lvalue})
+  true for unilateral contact with the ground
   """
 
-  weight_forces: any
+  weight_forces: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of forces for the optimization (if relevant)
   """
 
-  weight_moments: any
+  weight_moments: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of moments for optimization (if relevant)
   """
 
-  weight_tangentials: any
+  weight_tangentials: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Extra cost for tangential forces.
   """
 
-  width: any
+  width: float # double
   """
-  
-None( (placo.Contact6D)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact6D {lvalue})
+  Rectangular contact width along local y-axis.
   """
 
-  wrench: any
+  wrench: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Contact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::Contact {lvalue})
+  Wrench populated after the DynamicsSolver::solve call.
   """
 
   def zmp(
@@ -1122,67 +906,39 @@ class Distance:
   ) -> None:
     ...
 
-  min_distance: any
+  min_distance: float # double
   """
-  
-None( (placo.Distance)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::model::RobotWrapper::Distance {lvalue})
+  Current minimum distance between the two objects.
   """
 
-  objA: any
+  objA: int # int
   """
-  
-None( (placo.Distance)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::model::RobotWrapper::Distance {lvalue})
+  Index of object A in the collision geometry.
   """
 
-  objB: any
+  objB: int # int
   """
-  
-None( (placo.Distance)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::model::RobotWrapper::Distance {lvalue})
+  Index of object B in the collision geometry.
   """
 
-  parentA: any
+  parentA: any # pinocchio::JointIndex
   """
-  
-None( (placo.Distance)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::model::RobotWrapper::Distance {lvalue})
+  Parent joint of body A.
   """
 
-  parentB: any
+  parentB: any # pinocchio::JointIndex
   """
-  
-None( (placo.Distance)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::model::RobotWrapper::Distance {lvalue})
+  Parent joint of body B.
   """
 
-  pointA: any
+  pointA: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.Distance)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::model::RobotWrapper::Distance {lvalue})
+  Point of object A considered.
   """
 
-  pointB: any
+  pointB: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.Distance)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::model::RobotWrapper::Distance {lvalue})
+  Point of object B considered.
   """
 
 
@@ -1221,22 +977,14 @@ class DistanceConstraint:
     """
     ...
 
-  distance_max: any
+  distance_max: float # double
   """
-  
-None( (placo.DistanceConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::DistanceConstraint {lvalue})
+  Maximum distance allowed between frame A and frame B.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1246,13 +994,9 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class DistanceTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -1266,13 +1010,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -1292,13 +1032,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  distance: any
+  distance: float # double
   """
-  
-None( (placo.DistanceTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::DistanceTask {lvalue})
+  Target distance between A and B.
   """
 
   def error(
@@ -1317,31 +1053,19 @@ None( (placo.DistanceTask)arg1) -> float :
     """
     ...
 
-  frame_a: any
+  frame_a: any # pinocchio::FrameIndex
   """
-  
-None( (placo.DistanceTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::DistanceTask {lvalue})
+  Frame A.
   """
 
-  frame_b: any
+  frame_b: any # pinocchio::FrameIndex
   """
-  
-None( (placo.DistanceTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::DistanceTask {lvalue})
+  Frame B.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1359,31 +1083,19 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class DummyWalk:
-  T_world_left: any
+  T_world_left: numpy.ndarray # Eigen::Affine3d
   """
-  
-None( (placo.DummyWalk)arg1) -> object :
-
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  left foot in world, at begining of current step
   """
 
-  T_world_next: any
+  T_world_next: numpy.ndarray # Eigen::Affine3d
   """
-  
-None( (placo.DummyWalk)arg1) -> object :
-
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  Target for the current flying foot (given by support_left)
   """
 
-  T_world_right: any
+  T_world_right: numpy.ndarray # Eigen::Affine3d
   """
-  
-None( (placo.DummyWalk)arg1) -> object :
-
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  right foot in world, at begining of current step
   """
 
   def __init__(
@@ -1392,22 +1104,29 @@ None( (placo.DummyWalk)arg1) -> object :
   ) -> any:
     ...
 
-  feet_spacing: any
+  dtheta: float # double
+  """
+  Last requested step dtheta.
   """
-  
-None( (placo.DummyWalk)arg1) -> float :
 
-    C++ signature :
-        double {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  dx: float # double
+  """
+  Last requested step dx.
   """
 
-  lift_height: any
+  dy: float # double
+  """
+  Last requested step d-.
   """
-  
-None( (placo.DummyWalk)arg1) -> float :
 
-    C++ signature :
-        double {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  feet_spacing: float # double
+  """
+  Feet spacing [m].
+  """
+
+  lift_height: float # double
+  """
+  Lift height [m].
   """
 
   def next_step(
@@ -1438,49 +1157,29 @@ None( (placo.DummyWalk)arg1) -> float :
     """
     ...
 
-  robot: any
+  robot: RobotWrapper # placo::model::RobotWrapper
   """
-  
-None( (placo.DummyWalk)arg1) -> placo.RobotWrapper :
-
-    C++ signature :
-        placo::model::RobotWrapper {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  Robot wrapper.
   """
 
-  solver: any
+  solver: KinematicsSolver # placo::kinematics::KinematicsSolver
   """
-  
-None( (placo.DummyWalk)arg1) -> placo.KinematicsSolver :
-
-    C++ signature :
-        placo::kinematics::KinematicsSolver {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  Kinematics solver.
   """
 
-  support_left: any
+  support_left: bool # bool
   """
-  
-None( (placo.DummyWalk)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  Whether the current support is left or right.
   """
 
-  trunk_height: any
+  trunk_height: float # double
   """
-  
-None( (placo.DummyWalk)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  Trunk height [m].
   """
 
-  trunk_pitch: any
+  trunk_pitch: float # double
   """
-  
-None( (placo.DummyWalk)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  Trunk pitch angle [rad].
   """
 
   def update(
@@ -1507,13 +1206,9 @@ None( (placo.DummyWalk)arg1) -> float :
 
 
 class DynamicsCoMTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
   def __init__(
@@ -1522,13 +1217,9 @@ None( (placo.DynamicsTask)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -1548,76 +1239,44 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  ddtarget_world: any
+  ddtarget_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsCoMTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::CoMTask {lvalue})
+  Target acceleration in the world.
   """
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  dtarget_world: any
+  dtarget_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsCoMTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::CoMTask {lvalue})
+  Target velocity to reach in robot frame.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.DynamicsCoMTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::dynamics::CoMTask {lvalue})
+  Axises mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1625,13 +1284,9 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  target_world: any
+  target_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsCoMTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::CoMTask {lvalue})
+  Target to reach in world frame.
   """
 
 
@@ -1657,13 +1312,9 @@ class DynamicsConstraint:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1674,13 +1325,6 @@ None( (placo.Prioritized)arg1) -> str :
 
 class DynamicsFrameTask:
   T_world_frame: any
-  """
-  
-None( (placo.DynamicsFrameTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> None(placo::dynamics::FrameTask {lvalue})
-  """
 
   def __init__(
     arg1: object,
@@ -1719,13 +1363,9 @@ None( (placo.DynamicsFrameTask)arg1) -> object :
 
 
 class DynamicsGearTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
   def __init__(
@@ -1750,13 +1390,9 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -1776,49 +1412,29 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1845,13 +1461,9 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class DynamicsJointsTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
   def __init__(
@@ -1859,13 +1471,9 @@ None( (placo.DynamicsTask)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -1885,22 +1493,14 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
   def get_joint(
@@ -1914,31 +1514,19 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1980,22 +1568,14 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class DynamicsOrientationTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
-  R_world_frame: any
+  R_world_frame: numpy.ndarray # Eigen::Matrix3d
   """
-  
-None( (placo.DynamicsOrientationTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::dynamics::OrientationTask {lvalue})
+  Target orientation.
   """
 
   def __init__(
@@ -2005,13 +1585,9 @@ None( (placo.DynamicsOrientationTask)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -2031,76 +1607,44 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  domega_world: any
+  domega_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsOrientationTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::OrientationTask {lvalue})
+  Target angular acceleration.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.DynamicsOrientationTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::dynamics::OrientationTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
-  omega_world: any
+  omega_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsOrientationTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::OrientationTask {lvalue})
+  Target angular velocity.
   """
 
   priority: str
@@ -2110,13 +1654,9 @@ None( (placo.DynamicsOrientationTask)arg1) -> object :
 
 
 class DynamicsPositionTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
   def __init__(
@@ -2126,13 +1666,9 @@ None( (placo.DynamicsTask)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -2152,85 +1688,49 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  ddtarget_world: any
+  ddtarget_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsPositionTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::PositionTask {lvalue})
+  Target acceleration in the world.
   """
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  dtarget_world: any
+  dtarget_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsPositionTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::PositionTask {lvalue})
+  Target velocity in the world.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
-  frame_index: any
+  frame_index: any # pinocchio::FrameIndex
   """
-  
-None( (placo.DynamicsPositionTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::dynamics::PositionTask {lvalue})
+  Frame.
   """
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.DynamicsPositionTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::dynamics::PositionTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -2238,25 +1738,14 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  target_world: any
+  target_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsPositionTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::PositionTask {lvalue})
+  Target position in the world.
   """
 
 
 class DynamicsRelativeFrameTask:
   T_a_b: any
-  """
-  
-None( (placo.DynamicsRelativeFrameTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> None(placo::dynamics::RelativeFrameTask {lvalue})
-  """
 
   def __init__(
     arg1: object,
@@ -2295,22 +1784,14 @@ None( (placo.DynamicsRelativeFrameTask)arg1) -> object :
 
 
 class DynamicsRelativeOrientationTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
-  R_a_b: any
+  R_a_b: numpy.ndarray # Eigen::Matrix3d
   """
-  
-None( (placo.DynamicsRelativeOrientationTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::dynamics::RelativeOrientationTask {lvalue})
+  Target relative orientation.
   """
 
   def __init__(
@@ -2321,13 +1802,9 @@ None( (placo.DynamicsRelativeOrientationTask)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -2347,76 +1824,44 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  domega_a_b: any
+  domega_a_b: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsRelativeOrientationTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::RelativeOrientationTask {lvalue})
+  Target relative angular velocity.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.DynamicsRelativeOrientationTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::dynamics::RelativeOrientationTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
-  omega_a_b: any
+  omega_a_b: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsRelativeOrientationTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::RelativeOrientationTask {lvalue})
+  Target relative angular velocity.
   """
 
   priority: str
@@ -2426,13 +1871,9 @@ None( (placo.DynamicsRelativeOrientationTask)arg1) -> object :
 
 
 class DynamicsRelativePositionTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
   def __init__(
@@ -2443,13 +1884,9 @@ None( (placo.DynamicsTask)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -2469,76 +1906,44 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  ddtarget: any
+  ddtarget: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsRelativePositionTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::RelativePositionTask {lvalue})
+  Target relative acceleration.
   """
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  dtarget: any
+  dtarget: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsRelativePositionTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::RelativePositionTask {lvalue})
+  Target relative velocity.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.DynamicsRelativePositionTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::dynamics::RelativePositionTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -2546,13 +1951,9 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  target: any
+  target: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.DynamicsRelativePositionTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::dynamics::RelativePositionTask {lvalue})
+  Target relative position.
   """
 
 
@@ -2813,22 +2214,14 @@ class DynamicsSolver:
   ) -> int:
     ...
 
-  damping: any
+  damping: float # double
   """
-  
-None( (placo.DynamicsSolver)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::DynamicsSolver {lvalue})
+  Global damping that is added to all the joints.
   """
 
-  dt: any
+  dt: float # double
   """
-  
-None( (placo.DynamicsSolver)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::DynamicsSolver {lvalue})
+  Solver dt (seconds)
   """
 
   def dump_status(
@@ -2875,13 +2268,9 @@ None( (placo.DynamicsSolver)arg1) -> float :
     """
     ...
 
-  extra_force: any
+  extra_force: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.DynamicsSolver)arg1) -> numpy.ndarray :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> None(placo::dynamics::DynamicsSolver {lvalue})
+  Extra force to be added to the system (similar to non-linear terms)
   """
 
   def get_contact(
@@ -2890,13 +2279,9 @@ None( (placo.DynamicsSolver)arg1) -> numpy.ndarray :
   ) -> Contact:
     ...
 
-  gravity_only: any
+  gravity_only: bool # bool
   """
-  
-None( (placo.DynamicsSolver)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::DynamicsSolver {lvalue})
+  Use gravity only (no coriolis, no centrifugal)
   """
 
   def mask_fbase(
@@ -2908,13 +2293,9 @@ None( (placo.DynamicsSolver)arg1) -> bool :
     """
     ...
 
-  problem: any
+  problem: Problem # placo::problem::Problem
   """
-  
-None( (placo.DynamicsSolver)arg1) -> object :
-
-    C++ signature :
-        placo::problem::Problem {lvalue} None(placo::dynamics::DynamicsSolver {lvalue})
+  Instance of the problem.
   """
 
   def remove_constraint(
@@ -2950,14 +2331,7 @@ None( (placo.DynamicsSolver)arg1) -> object :
     """
     ...
 
-  robot: any
-  """
-  
-None( (placo.DynamicsSolver)arg1) -> object :
-
-    C++ signature :
-        placo::model::RobotWrapper None(placo::dynamics::DynamicsSolver)
-  """
+  robot: RobotWrapper # placo::model::RobotWrapper
 
   def set_kd(
     self,
@@ -3013,13 +2387,9 @@ None( (placo.DynamicsSolver)arg1) -> object :
   ) -> DynamicsSolverResult:
     ...
 
-  torque_cost: any
+  torque_cost: float # double
   """
-  
-None( (placo.DynamicsSolver)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::DynamicsSolver {lvalue})
+  Cost for torque regularization (1e-3 by default)
   """
 
 
@@ -3029,41 +2399,13 @@ class DynamicsSolverResult:
   ) -> None:
     ...
 
-  qdd: any
-  """
-  
-None( (placo.DynamicsSolverResult)arg1) -> object :
+  qdd: numpy.ndarray # Eigen::VectorXd
 
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::DynamicsSolver::Result {lvalue})
-  """
-
-  success: any
-  """
-  
-None( (placo.DynamicsSolverResult)arg1) -> bool :
+  success: bool # bool
 
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::DynamicsSolver::Result {lvalue})
-  """
-
-  tau: any
-  """
-  
-None( (placo.DynamicsSolverResult)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::DynamicsSolver::Result {lvalue})
-  """
-
-  tau_contacts: any
-  """
-  
-None( (placo.DynamicsSolverResult)arg1) -> object :
+  tau: numpy.ndarray # Eigen::VectorXd
 
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::DynamicsSolver::Result {lvalue})
-  """
+  tau_contacts: numpy.ndarray # Eigen::VectorXd
 
   def tau_dict(
     arg1: DynamicsSolverResult,
@@ -3073,26 +2415,18 @@ None( (placo.DynamicsSolverResult)arg1) -> object :
 
 
 class DynamicsTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
   def __init__(
   ) -> any:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -3112,49 +2446,29 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -3164,13 +2478,9 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class DynamicsTorqueTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  A matrix in Ax = b, where x is the accelerations.
   """
 
   def __init__(
@@ -3178,13 +2488,9 @@ None( (placo.DynamicsTask)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  b vector in Ax = b, where x is the accelerations
   """
 
   def configure(
@@ -3204,49 +2510,29 @@ None( (placo.DynamicsTask)arg1) -> object :
     """
     ...
 
-  derror: any
+  derror: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current velocity error vector.
   """
 
-  error: any
+  error: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.DynamicsTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::dynamics::Task {lvalue})
+  Current error vector.
   """
 
-  kd: any
+  kd: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  D gain for position control (if negative, will be critically damped)
   """
 
-  kp: any
+  kp: float # double
   """
-  
-None( (placo.DynamicsTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Task {lvalue})
+  K gain for position control.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -3287,13 +2573,9 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class Expression:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Expression)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::problem::Expression {lvalue})
+  Expression A matrix, in Ax + b.
   """
 
   def __init__(
@@ -3301,13 +2583,9 @@ None( (placo.Expression)arg1) -> object :
   ) -> any:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Expression)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::problem::Expression {lvalue})
+  Expression b vector, in Ax + b.
   """
 
   def cols(
@@ -3441,76 +2719,38 @@ class ExternalWrenchContact:
     """
     ...
 
-  active: any
+  active: bool # bool
   """
-  
-None( (placo.Contact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact {lvalue})
+  true if the contact is active (ignored by the solver else, this allow to enable/disable a contact without removing it from the solver)
   """
 
-  frame_index: any
-  """
-  
-None( (placo.ExternalWrenchContact)arg1) -> int :
+  frame_index: any # pinocchio::FrameIndex
 
-    C++ signature :
-        unsigned long {lvalue} None(placo::dynamics::ExternalWrenchContact {lvalue})
+  mu: float # double
   """
-
-  mu: any
+  Coefficient of friction (if relevant)
   """
-  
-None( (placo.Contact)arg1) -> float :
 
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
-  """
+  w_ext: numpy.ndarray # Eigen::VectorXd
 
-  w_ext: any
+  weight_forces: float # double
   """
-  
-None( (placo.ExternalWrenchContact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::ExternalWrenchContact {lvalue})
+  Weight of forces for the optimization (if relevant)
   """
 
-  weight_forces: any
+  weight_moments: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of moments for optimization (if relevant)
   """
 
-  weight_moments: any
+  weight_tangentials: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
-  """
-
-  weight_tangentials: any
-  """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Extra cost for tangential forces.
   """
 
-  wrench: any
+  wrench: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Contact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::Contact {lvalue})
+  Wrench populated after the DynamicsSolver::solve call.
   """
 
 
@@ -3608,32 +2848,11 @@ class Footstep:
   ) -> any:
     ...
 
-  foot_length: any
-  """
-  
-None( (placo.Footstep)arg1) -> float :
+  foot_length: float # double
 
-    C++ signature :
-        double {lvalue} None(placo::humanoid::FootstepsPlanner::Footstep {lvalue})
-  """
-
-  foot_width: any
-  """
-  
-None( (placo.Footstep)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::FootstepsPlanner::Footstep {lvalue})
-  """
-
-  frame: any
-  """
-  
-None( (placo.Footstep)arg1) -> object :
+  foot_width: float # double
 
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> {lvalue} None(placo::humanoid::FootstepsPlanner::Footstep {lvalue})
-  """
+  frame: numpy.ndarray # Eigen::Affine3d
 
   def overlap(
     self,
@@ -3657,14 +2876,7 @@ None( (placo.Footstep)arg1) -> object :
   ) -> None:
     ...
 
-  side: any
-  """
-  
-None( (placo.Footstep)arg1) -> placo.HumanoidRobot_Side :
-
-    C++ signature :
-        placo::humanoid::HumanoidRobot::Side {lvalue} None(placo::humanoid::FootstepsPlanner::Footstep {lvalue})
-  """
+  side: any # placo::humanoid::HumanoidRobot::Side
 
   def support_polygon(
     self,
@@ -3907,13 +3119,6 @@ class FootstepsPlannerRepetitive:
 
 class FrameTask:
   T_world_frame: any
-  """
-  
-None( (placo.FrameTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> None(placo::kinematics::FrameTask {lvalue})
-  """
 
   def __init__(
     self,
@@ -3955,13 +3160,9 @@ None( (placo.FrameTask)arg1) -> object :
 
 
 class GearTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -3989,13 +3190,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -4031,13 +3228,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -4077,14 +3270,7 @@ class HumanoidParameters:
   ) -> None:
     ...
 
-  dcm_offset_polygon: any
-  """
-  
-None( (placo.HumanoidParameters)arg1) -> placo.vector_Vector2d :
-
-    C++ signature :
-        std::__1::vector<Eigen::Matrix<double, 2, 1, 0, 2, 1>, std::__1::allocator<Eigen::Matrix<double, 2, 1, 0, 2, 1>>> {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
-  """
+  dcm_offset_polygon: list[numpy.ndarray] # std::vector< Eigen::Vector2d >
 
   def double_support_duration(
     self,
@@ -4094,13 +3280,9 @@ None( (placo.HumanoidParameters)arg1) -> placo.vector_Vector2d :
     """
     ...
 
-  double_support_ratio: any
+  double_support_ratio: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Duration ratio between single support and double support.
   """
 
   def double_support_timesteps(
@@ -4128,49 +3310,29 @@ None( (placo.HumanoidParameters)arg1) -> float :
     """
     ...
 
-  feet_spacing: any
+  feet_spacing: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Lateral spacing between feet [m].
   """
 
-  foot_length: any
+  foot_length: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Foot length [m].
   """
 
-  foot_width: any
+  foot_width: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Foot width [m].
   """
 
-  foot_zmp_target_x: any
+  foot_zmp_target_x: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Target offset for the ZMP x reference trajectory in the foot frame [m].
   """
 
-  foot_zmp_target_y: any
+  foot_zmp_target_y: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Target offset for the ZMP x reference trajectory in the foot frame, positive is "outward" [m].
   """
 
   def has_double_support(
@@ -4181,40 +3343,21 @@ None( (placo.HumanoidParameters)arg1) -> float :
     """
     ...
 
-  op_space_polygon: any
-  """
-  
-None( (placo.HumanoidParameters)arg1) -> placo.vector_Vector2d :
-
-    C++ signature :
-        std::__1::vector<Eigen::Matrix<double, 2, 1, 0, 2, 1>, std::__1::allocator<Eigen::Matrix<double, 2, 1, 0, 2, 1>>> {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
-  """
+  op_space_polygon: list[numpy.ndarray] # std::vector< Eigen::Vector2d >
 
-  planned_timesteps: any
+  planned_timesteps: int # int
   """
-  
-None( (placo.HumanoidParameters)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Planning horizon for the CoM trajectory.
   """
 
-  single_support_duration: any
+  single_support_duration: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Single support duration [s].
   """
 
-  single_support_timesteps: any
+  single_support_timesteps: int # int
   """
-  
-None( (placo.HumanoidParameters)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Number of timesteps for one single support.
   """
 
   def startend_double_support_duration(
@@ -4225,13 +3368,9 @@ None( (placo.HumanoidParameters)arg1) -> int :
     """
     ...
 
-  startend_double_support_ratio: any
+  startend_double_support_ratio: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Duration ratio between single support and start/end double support.
   """
 
   def startend_double_support_timesteps(
@@ -4242,103 +3381,59 @@ None( (placo.HumanoidParameters)arg1) -> float :
     """
     ...
 
-  walk_com_height: any
+  walk_com_height: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Target CoM height while walking [m].
   """
 
-  walk_dtheta_spacing: any
+  walk_dtheta_spacing: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  How much we need to space the feet per dtheta [m/rad].
   """
 
-  walk_foot_height: any
+  walk_foot_height: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  How height the feet are rising while walking [m].
   """
 
-  walk_foot_rise_ratio: any
+  walk_foot_rise_ratio: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  ratio of time spent at foot height during the step
   """
 
-  walk_max_dtheta: any
+  walk_max_dtheta: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Maximum step (yaw)
   """
 
-  walk_max_dx_backward: any
+  walk_max_dx_backward: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Maximum step (backward)
   """
 
-  walk_max_dx_forward: any
+  walk_max_dx_forward: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Maximum step (forward)
   """
 
-  walk_max_dy: any
+  walk_max_dy: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Maximum step (lateral)
   """
 
-  walk_trunk_pitch: any
+  walk_trunk_pitch: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Trunk pitch while walking [rad].
   """
 
-  zmp_margin: any
+  zmp_margin: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Margin for the ZMP to live in the support polygon [m].
   """
 
-  zmp_reference_weight: any
+  zmp_reference_weight: float # double
   """
-  
-None( (placo.HumanoidParameters)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::HumanoidParameters {lvalue})
+  Weight for ZMP reference in the solver.
   """
 
 
@@ -4368,13 +3463,9 @@ class HumanoidRobot:
     """
     ...
 
-  collision_model: any
+  collision_model: any # pinocchio::GeometryModel
   """
-  
-None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryModel :
-
-    C++ signature :
-        pinocchio::GeometryModel {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})
+  Pinocchio collision model.
   """
 
   def com_jacobian(
@@ -4429,7 +3520,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     """
     Computes all minimum distances between current collision pairs.
     
-    :return: <Element 'para' at 0x1080138d0>
+    :return: <Element 'para' at 0x105636c50>
     """
     ...
 
@@ -4462,7 +3553,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     
     :param any frame: the frame for which we want the jacobian 
     
-    :return: <Element 'para' at 0x108010a40>
+    :return: <Element 'para' at 0x105633b00>
     """
     ...
 
@@ -4476,7 +3567,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     
     :param any frame: the frame for which we want the jacobian time variation 
     
-    :return: <Element 'para' at 0x107fc0400>
+    :return: <Element 'para' at 0x1057039c0>
     """
     ...
 
@@ -4725,13 +3816,9 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     """
     ...
 
-  model: any
+  model: any # pinocchio::Model
   """
-  
-None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.Model :
-
-    C++ signature :
-        pinocchio::ModelTpl<double, 0, pinocchio::JointCollectionDefaultTpl> {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})
+  Pinocchio model.
   """
 
   def neutral_state(
@@ -4788,7 +3875,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.Model :
     
     :param bool stop_at_first: whether to stop at the first collision found 
     
-    :return: <Element 'para' at 0x1080126b0>
+    :return: <Element 'para' at 0x105637ab0>
     """
     ...
 
@@ -4950,13 +4037,9 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.Model :
     """
     ...
 
-  state: any
+  state: RobotWrapper_State # placo::model::RobotWrapper::State
   """
-  
-None( (placo.HumanoidRobot)arg1) -> placo.RobotWrapper_State :
-
-    C++ signature :
-        placo::model::RobotWrapper::State {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})
+  Robot's current state.
   """
 
   def static_gravity_compensation_torques(
@@ -4974,22 +4057,14 @@ None( (placo.HumanoidRobot)arg1) -> placo.RobotWrapper_State :
   ) -> dict:
     ...
 
-  support_is_both: any
+  support_is_both: bool # bool
   """
-  
-None( (placo.HumanoidRobot)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})
+  Are both feet supporting the robot.
   """
 
-  support_side: any
+  support_side: any # placo::humanoid::HumanoidRobot::Side
   """
-  
-None( (placo.HumanoidRobot)arg1) -> placo.HumanoidRobot_Side :
-
-    C++ signature :
-        placo::humanoid::HumanoidRobot::Side {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})
+  The current side (left or right) associated with T_world_support.
   """
 
   def torques_from_acceleration_with_fixed_frame(
@@ -5050,13 +4125,9 @@ None( (placo.HumanoidRobot)arg1) -> placo.HumanoidRobot_Side :
     """
     ...
 
-  visual_model: any
+  visual_model: any # pinocchio::GeometryModel
   """
-  
-None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryModel :
-
-    C++ signature :
-        pinocchio::GeometryModel {lvalue} None(placo::humanoid::HumanoidRobot {lvalue})
+  Pinocchio visual model.
   """
 
   def zmp(
@@ -5164,31 +4235,19 @@ class Integrator:
   """
   Integrator can be used to efficiently build expressions and values over a decision variable that is integrated over time with a given linear system.
   """
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Integrator)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::problem::Integrator {lvalue})
+  The discrete system matrix such that $X_{k+1} = A X_k + B u_k$.
   """
 
-  B: any
+  B: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Integrator)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::problem::Integrator {lvalue})
+  The discrete system matrix such that $X_{k+1} = A X_k + B u_k$.
   """
 
-  M: any
+  M: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Integrator)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::problem::Integrator {lvalue})
+  The continuous system matrix.
   """
 
   def __init__(
@@ -5224,13 +4283,9 @@ None( (placo.Integrator)arg1) -> object :
     """
     ...
 
-  final_transition_matrix: any
+  final_transition_matrix: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Integrator)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::problem::Integrator {lvalue})
+  Caching the discrete matrix for the last step.
   """
 
   def get_trajectory(
@@ -5241,13 +4296,9 @@ None( (placo.Integrator)arg1) -> object :
     """
     ...
 
-  t_start: any
+  t_start: float # double
   """
-  
-None( (placo.Integrator)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::problem::Integrator {lvalue})
+  Time offset for the trajectory.
   """
 
   @staticmethod
@@ -5305,13 +4356,9 @@ class IntegratorTrajectory:
 
 
 class JointSpaceHalfSpacesConstraint:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.JointSpaceHalfSpacesConstraint)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::JointSpaceHalfSpacesConstraint {lvalue})
+  Matrix A in Aq <= b.
   """
 
   def __init__(
@@ -5324,13 +4371,9 @@ None( (placo.JointSpaceHalfSpacesConstraint)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.JointSpaceHalfSpacesConstraint)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::kinematics::JointSpaceHalfSpacesConstraint {lvalue})
+  Vector b in Aq <= b.
   """
 
   def configure(
@@ -5350,13 +4393,9 @@ None( (placo.JointSpaceHalfSpacesConstraint)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -5366,13 +4405,9 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class JointsTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -5383,13 +4418,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -5436,13 +4467,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -5501,13 +4528,9 @@ class KinematicsConstraint:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -5517,13 +4540,9 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class KinematicsSolver:
-  N: any
+  N: int # int
   """
-  
-None( (placo.KinematicsSolver)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::kinematics::KinematicsSolver {lvalue})
+  Size of the problem (number of variables)
   """
 
   def __init__(
@@ -5864,13 +4883,9 @@ None( (placo.KinematicsSolver)arg1) -> int :
     """
     ...
 
-  dt: any
+  dt: float # double
   """
-  
-None( (placo.KinematicsSolver)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::KinematicsSolver {lvalue})
+  solver dt (for speeds limiting)
   """
 
   def dump_status(
@@ -5919,13 +4934,9 @@ None( (placo.KinematicsSolver)arg1) -> float :
     """
     ...
 
-  problem: any
+  problem: Problem # placo::problem::Problem
   """
-  
-None( (placo.KinematicsSolver)arg1) -> placo.Problem :
-
-    C++ signature :
-        placo::problem::Problem {lvalue} None(placo::kinematics::KinematicsSolver {lvalue})
+  The underlying QP problem.
   """
 
   def remove_constraint(
@@ -5950,22 +4961,14 @@ None( (placo.KinematicsSolver)arg1) -> placo.Problem :
     """
     ...
 
-  robot: any
+  robot: RobotWrapper # placo::model::RobotWrapper
   """
-  
-None( (placo.KinematicsSolver)arg1) -> placo.RobotWrapper :
-
-    C++ signature :
-        placo::model::RobotWrapper {lvalue} None(placo::kinematics::KinematicsSolver)
+  The robot controlled by this solver.
   """
 
-  scale: any
+  scale: float # double
   """
-  
-None( (placo.KinematicsSolver)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::KinematicsSolver {lvalue})
+  scale obtained when using tasks scaling
   """
 
   def solve(
@@ -6000,13 +5003,9 @@ None( (placo.KinematicsSolver)arg1) -> float :
 
 
 class KineticEnergyRegularizationTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -6014,13 +5013,9 @@ None( (placo.Task)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -6056,13 +5051,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6122,14 +5113,7 @@ class LIPM:
   ) -> Expression:
     ...
 
-  dt: any
-  """
-  
-None( (placo.LIPM)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::LIPM {lvalue})
-  """
+  dt: float # double
 
   def dzmp(
     self,
@@ -6159,31 +5143,10 @@ None( (placo.LIPM)arg1) -> float :
     ...
 
   t_end: any
-  """
-  
-None( (placo.LIPM)arg1) -> float :
 
-    C++ signature :
-        double None(placo::humanoid::LIPM {lvalue})
-  """
-
-  t_start: any
-  """
-  
-None( (placo.LIPM)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::LIPM {lvalue})
-  """
-
-  timesteps: any
-  """
-  
-None( (placo.LIPM)arg1) -> int :
+  t_start: float # double
 
-    C++ signature :
-        int {lvalue} None(placo::humanoid::LIPM {lvalue})
-  """
+  timesteps: int # int
 
   def vel(
     self,
@@ -6191,41 +5154,13 @@ None( (placo.LIPM)arg1) -> int :
   ) -> Expression:
     ...
 
-  x: any
-  """
-  
-None( (placo.LIPM)arg1) -> placo.Integrator :
-
-    C++ signature :
-        placo::problem::Integrator {lvalue} None(placo::humanoid::LIPM {lvalue})
-  """
-
-  x_var: any
-  """
-  
-None( (placo.LIPM)arg1) -> object :
-
-    C++ signature :
-        placo::problem::Variable* {lvalue} None(placo::humanoid::LIPM {lvalue})
-  """
-
-  y: any
-  """
-  
-None( (placo.LIPM)arg1) -> placo.Integrator :
+  x: Integrator # placo::problem::Integrator
 
-    C++ signature :
-        placo::problem::Integrator {lvalue} None(placo::humanoid::LIPM {lvalue})
-  """
+  x_var: Variable # placo::problem::Variable
 
-  y_var: any
-  """
-  
-None( (placo.LIPM)arg1) -> object :
+  y: Integrator # placo::problem::Integrator
 
-    C++ signature :
-        placo::problem::Variable* {lvalue} None(placo::humanoid::LIPM {lvalue})
-  """
+  y_var: Variable # placo::problem::Variable
 
   def zmp(
     self,
@@ -6288,13 +5223,9 @@ class LIPMTrajectory:
 
 
 class LineContact:
-  R_world_surface: any
+  R_world_surface: numpy.ndarray # Eigen::Matrix3d
   """
-  
-None( (placo.PointContact)arg1) -> numpy.ndarray :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 3, 0, 3, 3> None(placo::dynamics::PointContact {lvalue})
+  rotation matrix expressing the surface frame in the world frame (for unilateral contact)
   """
 
   def __init__(
@@ -6307,31 +5238,19 @@ None( (placo.PointContact)arg1) -> numpy.ndarray :
     """
     ...
 
-  active: any
+  active: bool # bool
   """
-  
-None( (placo.Contact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact {lvalue})
+  true if the contact is active (ignored by the solver else, this allow to enable/disable a contact without removing it from the solver)
   """
 
-  length: any
+  length: float # double
   """
-  
-None( (placo.LineContact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::LineContact {lvalue})
+  Rectangular contact length along local x-axis.
   """
 
-  mu: any
+  mu: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Coefficient of friction (if relevant)
   """
 
   def orientation_task(
@@ -6344,49 +5263,29 @@ None( (placo.Contact)arg1) -> float :
   ) -> DynamicsPositionTask:
     ...
 
-  unilateral: any
+  unilateral: bool # bool
   """
-  
-None( (placo.LineContact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::LineContact {lvalue})
+  true for unilateral contact with the ground
   """
 
-  weight_forces: any
+  weight_forces: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of forces for the optimization (if relevant)
   """
 
-  weight_moments: any
+  weight_moments: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of moments for optimization (if relevant)
   """
 
-  weight_tangentials: any
+  weight_tangentials: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Extra cost for tangential forces.
   """
 
-  wrench: any
+  wrench: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Contact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::Contact {lvalue})
+  Wrench populated after the DynamicsSolver::solve call.
   """
 
   def zmp(
@@ -6399,13 +5298,9 @@ None( (placo.Contact)arg1) -> object :
 
 
 class ManipulabilityTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -6416,13 +5311,9 @@ None( (placo.Task)arg1) -> object :
   ) -> any:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -6459,39 +5350,20 @@ None( (placo.Task)arg1) -> object :
     ...
 
   lambda_: any
-  """
-  
-None( (placo.ManipulabilityTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::ManipulabilityTask {lvalue})
-  """
 
-  manipulability: any
+  manipulability: float # double
   """
-  
-None( (placo.ManipulabilityTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::ManipulabilityTask {lvalue})
+  The last computed manipulability value.
   """
 
-  minimize: any
+  minimize: bool # bool
   """
-  
-None( (placo.ManipulabilityTask)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::kinematics::ManipulabilityTask {lvalue})
+  Should the manipulability be minimized (can be useful to find singularities)
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6509,22 +5381,14 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class OrientationTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
-  R_world_frame: any
+  R_world_frame: numpy.ndarray # Eigen::Matrix3d
   """
-  
-None( (placo.OrientationTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::kinematics::OrientationTask {lvalue})
+  Target frame orientation in the world.
   """
 
   def __init__(
@@ -6537,13 +5401,9 @@ None( (placo.OrientationTask)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -6579,31 +5439,19 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  frame_index: any
+  frame_index: any # pinocchio::FrameIndex
   """
-  
-None( (placo.OrientationTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::OrientationTask {lvalue})
+  Frame.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.OrientationTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::kinematics::OrientationTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6621,13 +5469,9 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class PointContact:
-  R_world_surface: any
+  R_world_surface: numpy.ndarray # Eigen::Matrix3d
   """
-  
-None( (placo.PointContact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::dynamics::PointContact {lvalue})
+  rotation matrix expressing the surface frame in the world frame (for unilateral contact)
   """
 
   def __init__(
@@ -6640,22 +5484,14 @@ None( (placo.PointContact)arg1) -> object :
     """
     ...
 
-  active: any
+  active: bool # bool
   """
-  
-None( (placo.Contact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact {lvalue})
+  true if the contact is active (ignored by the solver else, this allow to enable/disable a contact without removing it from the solver)
   """
 
-  mu: any
+  mu: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Coefficient of friction (if relevant)
   """
 
   def position_task(
@@ -6663,49 +5499,29 @@ None( (placo.Contact)arg1) -> float :
   ) -> DynamicsPositionTask:
     ...
 
-  unilateral: any
+  unilateral: bool # bool
   """
-  
-None( (placo.PointContact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::PointContact {lvalue})
+  true for unilateral contact with the ground
   """
 
-  weight_forces: any
+  weight_forces: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of forces for the optimization (if relevant)
   """
 
-  weight_moments: any
+  weight_moments: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of moments for optimization (if relevant)
   """
 
-  weight_tangentials: any
+  weight_tangentials: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Extra cost for tangential forces.
   """
 
-  wrench: any
+  wrench: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Contact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::Contact {lvalue})
+  Wrench populated after the DynamicsSolver::solve call.
   """
 
 
@@ -6745,13 +5561,9 @@ class Polynom:
   ) -> any:
     ...
 
-  coefficients: any
+  coefficients: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Polynom)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::tools::Polynom {lvalue})
+  coefficients, from highest to lowest
   """
 
   @staticmethod
@@ -6785,13 +5597,9 @@ None( (placo.Polynom)arg1) -> object :
 
 
 class PositionTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -6804,13 +5612,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -6846,31 +5650,19 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  frame_index: any
+  frame_index: any # pinocchio::FrameIndex
   """
-  
-None( (placo.PositionTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::PositionTask {lvalue})
+  Frame.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.PositionTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::kinematics::PositionTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6878,13 +5670,9 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  target_world: any
+  target_world: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.PositionTask)arg1) -> numpy.ndarray :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> None(placo::kinematics::PositionTask)
+  Target position in the world.
   """
 
   def update(
@@ -6919,13 +5707,9 @@ class Prioritized:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6992,13 +5776,9 @@ class Problem:
     """
     ...
 
-  determined_variables: any
+  determined_variables: int # int
   """
-  
-None( (placo.Problem)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Problem {lvalue})
+  Number of determined variables.
   """
 
   def dump_status(
@@ -7006,76 +5786,44 @@ None( (placo.Problem)arg1) -> int :
   ) -> None:
     ...
 
-  free_variables: any
+  free_variables: int # int
   """
-  
-None( (placo.Problem)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Problem {lvalue})
+  Number of free variables to solve.
   """
 
-  n_equalities: any
+  n_equalities: int # int
   """
-  
-None( (placo.Problem)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Problem {lvalue})
+  Number of equalities.
   """
 
-  n_inequalities: any
+  n_inequalities: int # int
   """
-  
-None( (placo.Problem)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Problem {lvalue})
+  Number of inequality constraints.
   """
 
-  n_variables: any
+  n_variables: int # int
   """
-  
-None( (placo.Problem)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Problem {lvalue})
+  Number of problem variables that need to be solved.
   """
 
-  regularization: any
+  regularization: float # double
   """
-  
-None( (placo.Problem)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::problem::Problem {lvalue})
+  Default internal regularization.
   """
 
-  rewrite_equalities: any
+  rewrite_equalities: bool # bool
   """
-  
-None( (placo.Problem)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::problem::Problem {lvalue})
+  If set to true, a QR factorization will be performed on the equality constraints, and the QP will be called with free variables only.
   """
 
-  slack_variables: any
+  slack_variables: int # int
   """
-  
-None( (placo.Problem)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Problem {lvalue})
+  Number of slack variables in the solver.
   """
 
-  slacks: any
+  slacks: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Problem)arg1) -> numpy.ndarray :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> None(placo::problem::Problem)
+  Computed slack variables.
   """
 
   def solve(
@@ -7086,22 +5834,14 @@ None( (placo.Problem)arg1) -> numpy.ndarray :
     """
     ...
 
-  use_sparsity: any
+  use_sparsity: bool # bool
   """
-  
-None( (placo.Problem)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::problem::Problem {lvalue})
+  If set to true, some sparsity optimizations will be performed when building the problem Hessian. This optimization is generally not useful for small problems.
   """
 
-  x: any
+  x: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Problem)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::problem::Problem {lvalue})
+  Computed result.
   """
 
 
@@ -7126,40 +5866,24 @@ class ProblemConstraint:
     """
     ...
 
-  expression: any
+  expression: Expression # placo::problem::Expression
   """
-  
-None( (placo.ProblemConstraint)arg1) -> object :
-
-    C++ signature :
-        placo::problem::Expression {lvalue} None(placo::problem::ProblemConstraint {lvalue})
+  The constraint expression (Ax + b)
   """
 
-  is_active: any
+  is_active: bool # bool
   """
-  
-None( (placo.ProblemConstraint)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::problem::ProblemConstraint {lvalue})
+  This flag will be set by the solver if the constraint is active in the optimal solution.
   """
 
-  priority: any
+  priority: any # placo::problem::ProblemConstraint::Priority
   """
-  
-None( (placo.ProblemConstraint)arg1) -> str :
-
-    C++ signature :
-        char const* None(placo::problem::ProblemConstraint)
+  Constraint priority.
   """
 
-  weight: any
+  weight: float # double
   """
-  
-None( (placo.ProblemConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::problem::ProblemConstraint {lvalue})
+  Constraint weight (for soft constraints)
   """
 
 
@@ -7202,58 +5926,34 @@ class PuppetContact:
     """
     ...
 
-  active: any
+  active: bool # bool
   """
-  
-None( (placo.Contact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact {lvalue})
+  true if the contact is active (ignored by the solver else, this allow to enable/disable a contact without removing it from the solver)
   """
 
-  mu: any
+  mu: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Coefficient of friction (if relevant)
   """
 
-  weight_forces: any
+  weight_forces: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of forces for the optimization (if relevant)
   """
 
-  weight_moments: any
+  weight_moments: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of moments for optimization (if relevant)
   """
 
-  weight_tangentials: any
+  weight_tangentials: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Extra cost for tangential forces.
   """
 
-  wrench: any
+  wrench: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Contact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::Contact {lvalue})
+  Wrench populated after the DynamicsSolver::solve call.
   """
 
 
@@ -7274,13 +5974,9 @@ class QPError:
 
 
 class RegularizationTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -7288,13 +5984,9 @@ None( (placo.Task)arg1) -> object :
   ) -> None:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -7330,13 +6022,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -7355,13 +6043,6 @@ None( (placo.Prioritized)arg1) -> str :
 
 class RelativeFrameTask:
   T_a_b: any
-  """
-  
-None( (placo.RelativeFrameTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> None(placo::kinematics::RelativeFrameTask {lvalue})
-  """
 
   def __init__(
     self,
@@ -7405,22 +6086,14 @@ None( (placo.RelativeFrameTask)arg1) -> object :
 
 
 class RelativeOrientationTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
-  R_a_b: any
+  R_a_b: numpy.ndarray # Eigen::Matrix3d
   """
-  
-None( (placo.RelativeOrientationTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 3, 0, 3, 3> {lvalue} None(placo::kinematics::RelativeOrientationTask {lvalue})
+  Target relative orientation of b in a.
   """
 
   def __init__(
@@ -7434,13 +6107,9 @@ None( (placo.RelativeOrientationTask)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -7476,40 +6145,24 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  frame_a: any
+  frame_a: any # pinocchio::FrameIndex
   """
-  
-None( (placo.RelativeOrientationTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::RelativeOrientationTask {lvalue})
+  Frame A.
   """
 
-  frame_b: any
+  frame_b: any # pinocchio::FrameIndex
   """
-  
-None( (placo.RelativeOrientationTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::RelativeOrientationTask {lvalue})
+  Frame B.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.RelativeOrientationTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::kinematics::RelativeOrientationTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -7527,13 +6180,9 @@ None( (placo.Prioritized)arg1) -> str :
 
 
 class RelativePositionTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
@@ -7547,13 +6196,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -7589,40 +6234,24 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  frame_a: any
+  frame_a: any # pinocchio::FrameIndex
   """
-  
-None( (placo.RelativePositionTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::RelativePositionTask {lvalue})
+  Frame A.
   """
 
-  frame_b: any
+  frame_b: any # pinocchio::FrameIndex
   """
-  
-None( (placo.RelativePositionTask)arg1) -> int :
-
-    C++ signature :
-        unsigned long {lvalue} None(placo::kinematics::RelativePositionTask {lvalue})
+  Frame B.
   """
 
-  mask: any
+  mask: AxisesMask # placo::tools::AxisesMask
   """
-  
-None( (placo.RelativePositionTask)arg1) -> placo.AxisesMask :
-
-    C++ signature :
-        placo::tools::AxisesMask {lvalue} None(placo::kinematics::RelativePositionTask {lvalue})
+  Mask.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -7630,13 +6259,9 @@ None( (placo.Prioritized)arg1) -> str :
   Priority [str]
   """
 
-  target: any
+  target: numpy.ndarray # Eigen::Vector3d
   """
-  
-None( (placo.RelativePositionTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 3, 1, 0, 3, 1> {lvalue} None(placo::kinematics::RelativePositionTask {lvalue})
+  Target position of B in A.
   """
 
   def update(
@@ -7683,13 +6308,9 @@ class RobotWrapper:
     """
     ...
 
-  collision_model: any
+  collision_model: any # pinocchio::GeometryModel
   """
-  
-None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryModel :
-
-    C++ signature :
-        pinocchio::GeometryModel {lvalue} None(placo::model::RobotWrapper {lvalue})
+  Pinocchio collision model.
   """
 
   def com_jacobian(
@@ -7730,7 +6351,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     """
     Computes all minimum distances between current collision pairs.
     
-    :return: <Element 'para' at 0x107f60e00>
+    :return: <Element 'para' at 0x105688f90>
     """
     ...
 
@@ -7744,7 +6365,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     
     :param any frame: the frame for which we want the jacobian 
     
-    :return: <Element 'para' at 0x107f618a0>
+    :return: <Element 'para' at 0x105689a30>
     """
     ...
 
@@ -7758,7 +6379,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     
     :param any frame: the frame for which we want the jacobian time variation 
     
-    :return: <Element 'para' at 0x107f63010>
+    :return: <Element 'para' at 0x10568b1a0>
     """
     ...
 
@@ -7943,13 +6564,9 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     """
     ...
 
-  model: any
+  model: any # pinocchio::Model
   """
-  
-None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.Model :
-
-    C++ signature :
-        pinocchio::ModelTpl<double, 0, pinocchio::JointCollectionDefaultTpl> {lvalue} None(placo::model::RobotWrapper {lvalue})
+  Pinocchio model.
   """
 
   def neutral_state(
@@ -7999,7 +6616,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.Model :
     
     :param bool stop_at_first: whether to stop at the first collision found 
     
-    :return: <Element 'para' at 0x107f605e0>
+    :return: <Element 'para' at 0x105688770>
     """
     ...
 
@@ -8155,13 +6772,9 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.Model :
     """
     ...
 
-  state: any
+  state: RobotWrapper_State # placo::model::RobotWrapper::State
   """
-  
-None( (placo.RobotWrapper)arg1) -> placo.RobotWrapper_State :
-
-    C++ signature :
-        placo::model::RobotWrapper::State {lvalue} None(placo::model::RobotWrapper {lvalue})
+  Robot's current state.
   """
 
   def static_gravity_compensation_torques(
@@ -8217,13 +6830,9 @@ None( (placo.RobotWrapper)arg1) -> placo.RobotWrapper_State :
     """
     ...
 
-  visual_model: any
+  visual_model: any # pinocchio::GeometryModel
   """
-  
-None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryModel :
-
-    C++ signature :
-        pinocchio::GeometryModel {lvalue} None(placo::model::RobotWrapper {lvalue})
+  Pinocchio visual model.
   """
 
 
@@ -8233,31 +6842,19 @@ class RobotWrapper_State:
   ) -> None:
     ...
 
-  q: any
+  q: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.RobotWrapper_State)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::model::RobotWrapper::State {lvalue})
+  joints configuration $q$
   """
 
-  qd: any
+  qd: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.RobotWrapper_State)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::model::RobotWrapper::State {lvalue})
+  joints velocity $\dot q$
   """
 
-  qdd: any
+  qdd: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.RobotWrapper_State)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::model::RobotWrapper::State {lvalue})
+  joints acceleration $\ddot q$
   """
 
 
@@ -8267,14 +6864,7 @@ class Segment:
   ) -> any:
     ...
 
-  end: any
-  """
-  
-None( (placo.Segment)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 2, 1, 0, 2, 1> {lvalue} None(placo::tools::Segment {lvalue})
-  """
+  end: numpy.ndarray # Eigen::Vector2d
 
   def half_line_pass_through(
     self,
@@ -8381,14 +6971,7 @@ None( (placo.Segment)arg1) -> object :
   ) -> float:
     ...
 
-  start: any
-  """
-  
-None( (placo.Segment)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 2, 1, 0, 2, 1> {lvalue} None(placo::tools::Segment {lvalue})
-  """
+  start: numpy.ndarray # Eigen::Vector2d
 
 
 class Sparsity:
@@ -8423,13 +7006,9 @@ class Sparsity:
     """
     ...
 
-  intervals: any
+  intervals: list[SparsityInterval] # std::vector<placo::problem::Sparsity::Interval>
   """
-  
-None( (placo.Sparsity)arg1) -> numpy.ndarray :
-
-    C++ signature :
-        Eigen::Matrix<int, -1, -1, 0, -1, -1> None(placo::problem::Sparsity)
+  Intervals of non-sparse columns.
   """
 
   def print_intervals(
@@ -8447,22 +7026,14 @@ class SparsityInterval:
   ) -> None:
     ...
 
-  end: any
+  end: int # int
   """
-  
-None( (placo.SparsityInterval)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Sparsity::Interval {lvalue})
+  End of interval.
   """
 
-  start: any
+  start: int # int
   """
-  
-None( (placo.SparsityInterval)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Sparsity::Interval {lvalue})
+  Start of interval.
   """
 
 
@@ -8478,23 +7049,9 @@ class Support:
   ) -> None:
     ...
 
-  elapsed_ratio: any
-  """
-  
-None( (placo.Support)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})
-  """
-
-  end: any
-  """
-  
-None( (placo.Support)arg1) -> bool :
+  elapsed_ratio: float # double
 
-    C++ signature :
-        bool {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})
-  """
+  end: bool # bool
 
   def footstep_frame(
     self,
@@ -8507,14 +7064,7 @@ None( (placo.Support)arg1) -> bool :
     """
     ...
 
-  footsteps: any
-  """
-  
-None( (placo.Support)arg1) -> object :
-
-    C++ signature :
-        std::__1::vector<placo::humanoid::FootstepsPlanner::Footstep, std::__1::allocator<placo::humanoid::FootstepsPlanner::Footstep>> {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})
-  """
+  footsteps: list[Footstep] # std::vector<placo::humanoid::FootstepsPlanner::Footstep>
 
   def frame(
     self,
@@ -8552,46 +7102,18 @@ None( (placo.Support)arg1) -> object :
     """
     ...
 
-  start: any
-  """
-  
-None( (placo.Support)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})
-  """
+  start: bool # bool
 
   def support_polygon(
     self,
   ) -> list[numpy.ndarray]:
     ...
 
-  t_start: any
-  """
-  
-None( (placo.Support)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})
-  """
-
-  target_world_dcm: any
-  """
-  
-None( (placo.Support)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, 2, 1, 0, 2, 1> {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})
-  """
+  t_start: float # double
 
-  time_ratio: any
-  """
-  
-None( (placo.Support)arg1) -> float :
+  target_world_dcm: numpy.ndarray # Eigen::Vector2d
 
-    C++ signature :
-        double {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})
-  """
+  time_ratio: float # double
 
 
 class Supports:
@@ -8740,26 +7262,18 @@ class SwingFootTrajectory:
 
 
 class Task:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
   def __init__(
   ) -> any:
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -8795,13 +7309,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -8828,58 +7338,34 @@ class TaskContact:
     """
     ...
 
-  active: any
+  active: bool # bool
   """
-  
-None( (placo.Contact)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact {lvalue})
+  true if the contact is active (ignored by the solver else, this allow to enable/disable a contact without removing it from the solver)
   """
 
-  mu: any
+  mu: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Coefficient of friction (if relevant)
   """
 
-  weight_forces: any
+  weight_forces: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of forces for the optimization (if relevant)
   """
 
-  weight_moments: any
+  weight_moments: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Weight of moments for optimization (if relevant)
   """
 
-  weight_tangentials: any
+  weight_tangentials: float # double
   """
-  
-None( (placo.Contact)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  Extra cost for tangential forces.
   """
 
-  wrench: any
+  wrench: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Contact)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::Contact {lvalue})
+  Wrench populated after the DynamicsSolver::solve call.
   """
 
 
@@ -8906,31 +7392,19 @@ class Variable:
     """
     ...
 
-  k_end: any
+  k_end: int # int
   """
-  
-None( (placo.Variable)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Variable {lvalue})
+  End offset in the Problem.
   """
 
-  k_start: any
+  k_start: int # int
   """
-  
-None( (placo.Variable)arg1) -> int :
-
-    C++ signature :
-        int {lvalue} None(placo::problem::Variable {lvalue})
+  Start offset in the Problem.
   """
 
-  value: any
+  value: numpy.ndarray # Eigen::VectorXd
   """
-  
-None( (placo.Variable)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::problem::Variable {lvalue})
+  Variable value, populated by Problem after a solve.
   """
 
 
@@ -8953,14 +7427,7 @@ class WPGTrajectory:
     """
     ...
 
-  com_target_z: any
-  """
-  
-None( (placo.WPGTrajectory)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})
-  """
+  com_target_z: float # double
 
   def get_R_world_trunk(
     self,
@@ -9112,28 +7579,14 @@ None( (placo.WPGTrajectory)arg1) -> float :
   ) -> numpy.ndarray:
     ...
 
-  parts: any
-  """
-  
-None( (placo.WPGTrajectory)arg1) -> object :
-
-    C++ signature :
-        std::__1::vector<placo::humanoid::WalkPatternGenerator::TrajectoryPart, std::__1::allocator<placo::humanoid::WalkPatternGenerator::TrajectoryPart>> {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})
-  """
+  parts: list[WPGTrajectoryPart] # std::vector<placo::humanoid::WalkPatternGenerator::TrajectoryPart>
 
   def print_parts_timings(
     self,
   ) -> None:
     ...
 
-  replan_success: any
-  """
-  
-None( (placo.WPGTrajectory)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})
-  """
+  replan_success: bool # bool
 
   def support_is_both(
     self,
@@ -9147,41 +7600,13 @@ None( (placo.WPGTrajectory)arg1) -> bool :
   ) -> any:
     ...
 
-  t_end: any
-  """
-  
-None( (placo.WPGTrajectory)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})
-  """
-
-  t_start: any
-  """
-  
-None( (placo.WPGTrajectory)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})
-  """
+  t_end: float # double
 
-  trunk_pitch: any
-  """
-  
-None( (placo.WPGTrajectory)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})
-  """
+  t_start: float # double
 
-  trunk_roll: any
-  """
-  
-None( (placo.WPGTrajectory)arg1) -> float :
+  trunk_pitch: float # double
 
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator::Trajectory {lvalue})
-  """
+  trunk_roll: float # double
 
 
 class WPGTrajectoryPart:
@@ -9192,32 +7617,11 @@ class WPGTrajectoryPart:
   ) -> None:
     ...
 
-  support: any
-  """
-  
-None( (placo.WPGTrajectoryPart)arg1) -> placo.Support :
-
-    C++ signature :
-        placo::humanoid::FootstepsPlanner::Support {lvalue} None(placo::humanoid::WalkPatternGenerator::TrajectoryPart {lvalue})
-  """
-
-  t_end: any
-  """
-  
-None( (placo.WPGTrajectoryPart)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator::TrajectoryPart {lvalue})
-  """
+  support: Support # placo::humanoid::FootstepsPlanner::Support
 
-  t_start: any
-  """
-  
-None( (placo.WPGTrajectoryPart)arg1) -> float :
+  t_end: float # double
 
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator::TrajectoryPart {lvalue})
-  """
+  t_start: float # double
 
 
 class WalkPatternGenerator:
@@ -9300,23 +7704,9 @@ class WalkPatternGenerator:
     """
     ...
 
-  soft: any
-  """
-  
-None( (placo.WalkPatternGenerator)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::humanoid::WalkPatternGenerator {lvalue})
-  """
+  soft: bool # bool
 
-  stop_end_support_weight: any
-  """
-  
-None( (placo.WalkPatternGenerator)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator {lvalue})
-  """
+  stop_end_support_weight: float # double
 
   def support_default_duration(
     self,
@@ -9347,14 +7737,7 @@ None( (placo.WalkPatternGenerator)arg1) -> float :
     """
     ...
 
-  zmp_in_support_weight: any
-  """
-  
-None( (placo.WalkPatternGenerator)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkPatternGenerator {lvalue})
-  """
+  zmp_in_support_weight: float # double
 
 
 class WalkTasks:
@@ -9363,32 +7746,11 @@ class WalkTasks:
   ) -> None:
     ...
 
-  com_task: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> placo.CoMTask :
-
-    C++ signature :
-        placo::kinematics::CoMTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
-
-  com_x: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
+  com_task: CoMTask # placo::kinematics::CoMTask
 
-  com_y: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> float :
+  com_x: float # double
 
-    C++ signature :
-        double {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
+  com_y: float # double
 
   def get_tasks_error(
     self,
@@ -9402,14 +7764,7 @@ None( (placo.WalkTasks)arg1) -> float :
   ) -> None:
     ...
 
-  left_foot_task: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> placo.FrameTask :
-
-    C++ signature :
-        placo::kinematics::FrameTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
+  left_foot_task: FrameTask # placo::kinematics::FrameTask
 
   def reach_initial_pose(
     self,
@@ -9425,59 +7780,17 @@ None( (placo.WalkTasks)arg1) -> placo.FrameTask :
   ) -> None:
     ...
 
-  right_foot_task: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> placo.FrameTask :
-
-    C++ signature :
-        placo::kinematics::FrameTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
-
-  scaled: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
-
-  solver: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> placo.KinematicsSolver :
-
-    C++ signature :
-        placo::kinematics::KinematicsSolver None(placo::humanoid::WalkTasks {lvalue})
-  """
-
-  trunk_mode: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> bool :
+  right_foot_task: FrameTask # placo::kinematics::FrameTask
 
-    C++ signature :
-        bool {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
+  scaled: bool # bool
 
-  trunk_orientation_task: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> placo.OrientationTask :
+  solver: KinematicsSolver # placo::kinematics::KinematicsSolver
 
-    C++ signature :
-        placo::kinematics::OrientationTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
+  trunk_mode: bool # bool
 
-  trunk_task: any
-  """
-  
-None( (placo.WalkTasks)arg1) -> placo.PositionTask :
+  trunk_orientation_task: OrientationTask # placo::kinematics::OrientationTask
 
-    C++ signature :
-        placo::kinematics::PositionTask {lvalue} None(placo::humanoid::WalkTasks {lvalue})
-  """
+  trunk_task: PositionTask # placo::kinematics::PositionTask
 
   def update_tasks(
     self,
@@ -9495,22 +7808,14 @@ None( (placo.WalkTasks)arg1) -> placo.PositionTask :
 
 
 class WheelTask:
-  A: any
+  A: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Matrix A in the task Ax = b, where x are the joint delta positions.
   """
 
-  T_world_surface: any
+  T_world_surface: numpy.ndarray # Eigen::Affine3d
   """
-  
-None( (placo.WheelTask)arg1) -> object :
-
-    C++ signature :
-        Eigen::Transform<double, 3, 2, 0> {lvalue} None(placo::kinematics::WheelTask {lvalue})
+  Target position in the world.
   """
 
   def __init__(
@@ -9524,13 +7829,9 @@ None( (placo.WheelTask)arg1) -> object :
     """
     ...
 
-  b: any
+  b: numpy.ndarray # Eigen::MatrixXd
   """
-  
-None( (placo.Task)arg1) -> object :
-
-    C++ signature :
-        Eigen::Matrix<double, -1, -1, 0, -1, -1> {lvalue} None(placo::kinematics::Task {lvalue})
+  Vector b in the task Ax = b, where x are the joint delta positions.
   """
 
   def configure(
@@ -9566,31 +7867,19 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  joint: any
+  joint: str # std::string
   """
-  
-None( (placo.WheelTask)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::kinematics::WheelTask {lvalue})
+  Frame.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
-  omniwheel: any
+  omniwheel: bool # bool
   """
-  
-None( (placo.WheelTask)arg1) -> bool :
-
-    C++ signature :
-        bool {lvalue} None(placo::kinematics::WheelTask {lvalue})
+  Omniwheel (can slide laterally)
   """
 
   priority: str
@@ -9598,13 +7887,9 @@ None( (placo.WheelTask)arg1) -> bool :
   Priority [str]
   """
 
-  radius: any
+  radius: float # double
   """
-  
-None( (placo.WheelTask)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::WheelTask {lvalue})
+  Wheel radius.
   """
 
   def update(
@@ -9634,13 +7919,9 @@ class YawConstraint:
     """
     ...
 
-  angle_max: any
+  angle_max: float # double
   """
-  
-None( (placo.YawConstraint)arg1) -> float :
-
-    C++ signature :
-        double {lvalue} None(placo::kinematics::YawConstraint {lvalue})
+  Maximum angle allowable by the yaw constraint (yaw is taken for x-axis of b around z-axis in a)
   """
 
   def configure(
@@ -9660,13 +7941,9 @@ None( (placo.YawConstraint)arg1) -> float :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str