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

cmeel.prefix/lib/python3.10/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.
   """
 
 
@@ -3604,32 +2844,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,
@@ -3653,14 +2872,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,
@@ -3903,13 +3115,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,
@@ -3951,13 +3156,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__(
@@ -3985,13 +3186,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(
@@ -4027,13 +3224,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
@@ -4073,14 +3266,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,
@@ -4090,13 +3276,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(
@@ -4124,49 +3306,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(
@@ -4177,40 +3339,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(
@@ -4221,13 +3364,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(
@@ -4238,103 +3377,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.
   """
 
 
@@ -4364,13 +3459,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(
@@ -4425,7 +3516,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     """
     Computes all minimum distances between current collision pairs.
     
-    :return: <Element 'para' at 0x1076353a0>
+    :return: <Element 'para' at 0x1074ff880>
     """
     ...
 
@@ -4458,7 +3549,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 0x107635e90>
+    :return: <Element 'para' at 0x1074ffa60>
     """
     ...
 
@@ -4472,7 +3563,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 0x107637880>
+    :return: <Element 'para' at 0x1074e0bd0>
     """
     ...
 
@@ -4721,13 +3812,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(
@@ -4784,7 +3871,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 0x107634c70>
+    :return: <Element 'para' at 0x1074a48b0>
     """
     ...
 
@@ -4946,13 +4033,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(
@@ -4970,22 +4053,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(
@@ -5046,13 +4121,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(
@@ -5156,31 +4227,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__(
@@ -5216,13 +4275,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(
@@ -5233,13 +4288,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
@@ -5297,13 +4348,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__(
@@ -5316,13 +4363,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(
@@ -5342,13 +4385,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
@@ -5358,13 +4397,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__(
@@ -5375,13 +4410,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(
@@ -5428,13 +4459,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
@@ -5493,13 +4520,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
@@ -5509,13 +4532,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__(
@@ -5856,13 +4875,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(
@@ -5911,13 +4926,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(
@@ -5942,22 +4953,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(
@@ -5992,13 +4995,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__(
@@ -6006,13 +5005,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(
@@ -6048,13 +5043,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
@@ -6114,14 +5105,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,
@@ -6151,31 +5135,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,
@@ -6183,41 +5146,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,
@@ -6280,13 +5215,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__(
@@ -6299,31 +5230,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(
@@ -6336,49 +5255,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(
@@ -6391,13 +5290,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__(
@@ -6408,13 +5303,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(
@@ -6451,39 +5342,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
@@ -6501,22 +5373,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__(
@@ -6529,13 +5393,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(
@@ -6571,31 +5431,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
@@ -6613,13 +5461,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__(
@@ -6632,22 +5476,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(
@@ -6655,49 +5491,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.
   """
 
 
@@ -6737,13 +5553,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
@@ -6777,13 +5589,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__(
@@ -6796,13 +5604,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(
@@ -6838,31 +5642,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
@@ -6870,13 +5662,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(
@@ -6911,13 +5699,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
@@ -6984,13 +5768,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(
@@ -6998,76 +5778,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(
@@ -7078,22 +5826,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.
   """
 
 
@@ -7118,40 +5858,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)
   """
 
 
@@ -7194,58 +5918,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.
   """
 
 
@@ -7266,13 +5966,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__(
@@ -7280,13 +5976,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(
@@ -7322,13 +6014,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
@@ -7347,13 +6035,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,
@@ -7397,22 +6078,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__(
@@ -7426,13 +6099,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(
@@ -7468,40 +6137,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
@@ -7519,13 +6172,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__(
@@ -7539,13 +6188,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(
@@ -7581,40 +6226,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
@@ -7622,13 +6251,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(
@@ -7675,13 +6300,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(
@@ -7722,7 +6343,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     """
     Computes all minimum distances between current collision pairs.
     
-    :return: <Element 'para' at 0x107585d00>
+    :return: <Element 'para' at 0x1074edee0>
     """
     ...
 
@@ -7736,7 +6357,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 0x1075867f0>
+    :return: <Element 'para' at 0x1074ee9d0>
     """
     ...
 
@@ -7750,7 +6371,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 0x107594220>
+    :return: <Element 'para' at 0x1074fc400>
     """
     ...
 
@@ -7935,13 +6556,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(
@@ -7991,7 +6608,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 0x1075855d0>
+    :return: <Element 'para' at 0x1074ed7b0>
     """
     ...
 
@@ -8147,13 +6764,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(
@@ -8209,13 +6822,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.
   """
 
 
@@ -8225,31 +6834,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$
   """
 
 
@@ -8259,14 +6856,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,
@@ -8373,14 +6963,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:
@@ -8415,13 +6998,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(
@@ -8439,22 +7018,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.
   """
 
 
@@ -8470,23 +7041,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,
@@ -8499,14 +7056,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,
@@ -8544,46 +7094,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:
@@ -8732,26 +7254,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(
@@ -8787,13 +7301,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
@@ -8820,58 +7330,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.
   """
 
 
@@ -8898,31 +7384,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.
   """
 
 
@@ -8945,14 +7419,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,
@@ -9104,28 +7571,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,
@@ -9139,41 +7592,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:
@@ -9184,32 +7609,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:
@@ -9292,23 +7696,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,
@@ -9339,14 +7729,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:
@@ -9355,32 +7738,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,
@@ -9394,14 +7756,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,
@@ -9417,59 +7772,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,
@@ -9487,22 +7800,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__(
@@ -9516,13 +7821,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(
@@ -9558,31 +7859,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
@@ -9590,13 +7879,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(
@@ -9626,13 +7911,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(
@@ -9652,13 +7933,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