placo 0.9.6__0-cp311-cp311-manylinux_2_28_aarch64.whl → 0.9.8__0-cp311-cp311-manylinux_2_28_aarch64.whl

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

@@ -121,13 +121,9 @@ class AvoidSelfCollisionsDynamicsConstraint:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -135,22 +131,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].
   """
 
 
@@ -175,13 +163,9 @@ class AvoidSelfCollisionsKinematicsConstraint:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -189,33 +173,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__(
@@ -226,22 +198,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(
@@ -275,22 +239,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -298,13 +254,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(
@@ -317,22 +269,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__(
@@ -366,22 +310,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__(
@@ -393,13 +329,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(
@@ -433,22 +365,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -493,49 +417,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::__cxx11::basic_string<char, std::char_traits<char>, std::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::vector<Eigen::Matrix<double, 2, 1, 0, 2, 1>, std::allocator<Eigen::Matrix<double, 2, 1, 0, 2, 1> > > {lvalue} None(placo::kinematics::CoMPolygonConstraint {lvalue})
+  Clockwise polygon.
   """
 
   priority: str
@@ -545,13 +449,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__(
@@ -563,13 +463,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(
@@ -603,22 +499,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -626,13 +514,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(
@@ -650,22 +534,14 @@ class Collision:
   ) -> None:
     ...
 
-  bodyA: any
+  bodyA: str # std::string
   """
-  
-None( (placo.Collision)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::model::RobotWrapper::Collision {lvalue})
+  Name of the body B.
   """
 
   def get_contact(
@@ -674,51 +550,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__(
@@ -732,13 +588,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(
@@ -756,13 +608,9 @@ None( (placo.ConeConstraint)arg1) -> float :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -770,13 +618,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.
   """
 
 
@@ -786,58 +630,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.
   """
 
 
@@ -852,31 +672,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(
@@ -889,58 +697,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(
@@ -1097,67 +881,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.
   """
 
 
@@ -1188,22 +944,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1213,13 +961,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__(
@@ -1233,13 +977,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(
@@ -1257,13 +997,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(
@@ -1282,31 +1018,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1324,31 +1048,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__(
@@ -1357,22 +1069,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(
@@ -1401,49 +1120,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(
@@ -1468,13 +1167,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__(
@@ -1483,13 +1178,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(
@@ -1507,76 +1198,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1584,13 +1243,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.
   """
 
 
@@ -1614,13 +1269,9 @@ class DynamicsConstraint:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1631,13 +1282,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,
@@ -1673,13 +1317,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__(
@@ -1702,13 +1342,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(
@@ -1726,49 +1362,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1793,13 +1409,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__(
@@ -1807,13 +1419,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(
@@ -1831,22 +1439,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(
@@ -1860,31 +1460,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -1923,22 +1511,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__(
@@ -1948,13 +1528,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(
@@ -1972,76 +1548,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::__cxx11::basic_string<char, std::char_traits<char>, std::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
@@ -2051,13 +1595,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__(
@@ -2067,13 +1607,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(
@@ -2091,85 +1627,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -2177,25 +1677,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,
@@ -2231,22 +1720,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__(
@@ -2257,13 +1738,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(
@@ -2281,76 +1758,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::__cxx11::basic_string<char, std::char_traits<char>, std::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
@@ -2360,13 +1805,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__(
@@ -2377,13 +1818,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(
@@ -2401,76 +1838,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -2478,13 +1883,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.
   """
 
 
@@ -2741,22 +2142,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(
@@ -2803,13 +2196,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(
@@ -2818,13 +2207,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(
@@ -2836,13 +2221,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(
@@ -2876,14 +2257,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,
@@ -2929,13 +2303,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)
   """
 
 
@@ -2945,41 +2315,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,
@@ -2989,26 +2331,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(
@@ -3026,49 +2360,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -3078,13 +2392,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__(
@@ -3092,13 +2402,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(
@@ -3116,49 +2422,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -3196,13 +2482,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__(
@@ -3210,13 +2492,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(
@@ -3345,76 +2623,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.
   """
 
 
@@ -3508,32 +2748,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,
@@ -3557,14 +2776,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,
@@ -3793,13 +3005,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,
@@ -3838,13 +3043,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__(
@@ -3870,13 +3071,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(
@@ -3910,13 +3107,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -3954,14 +3147,7 @@ class HumanoidParameters:
   ) -> None:
     ...
 
-  dcm_offset_polygon: any
-  """
-  
-None( (placo.HumanoidParameters)arg1) -> placo.vector_Vector2d :
-
-    C++ signature :
-        std::vector<Eigen::Matrix<double, 2, 1, 0, 2, 1>, std::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,
@@ -3971,13 +3157,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(
@@ -4005,49 +3187,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(
@@ -4058,40 +3220,21 @@ None( (placo.HumanoidParameters)arg1) -> float :
     """
     ...
 
-  op_space_polygon: any
-  """
-  
-None( (placo.HumanoidParameters)arg1) -> placo.vector_Vector2d :
-
-    C++ signature :
-        std::vector<Eigen::Matrix<double, 2, 1, 0, 2, 1>, std::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(
@@ -4102,13 +3245,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(
@@ -4119,103 +3258,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.
   """
 
 
@@ -4245,13 +3340,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(
@@ -4305,7 +3396,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     """
     Computes all minimum distances between current collision pairs.
     
-    :return: <Element 'para' at 0xffa07c95c8b0>
+    :return: <Element 'para' at 0xffb37a535800>
     """
     ...
 
@@ -4337,7 +3428,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     Frame jacobian, default reference is LOCAL_WORLD_ALIGNED.
     
     :param any frame: the frame for which we want the jacobian 
-    :return: <Element 'para' at 0xffa07c95d350>
+    :return: <Element 'para' at 0xffb37a5362a0>
     """
     ...
 
@@ -4350,7 +3441,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     Jacobian time variation $\dot J$, default reference is LOCAL_WORLD_ALIGNED.
     
     :param any frame: the frame for which we want the jacobian time variation 
-    :return: <Element 'para' at 0xffa07c95eca0>
+    :return: <Element 'para' at 0xffb37a537bf0>
     """
     ...
 
@@ -4595,13 +3686,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(
@@ -4656,7 +3743,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.Model :
     Finds the self collision in current state, if stop_at_first is true, it will stop at the first collision found.
     
     :param bool stop_at_first: whether to stop at the first collision found 
-    :return: <Element 'para' at 0xffa07c95c1d0>
+    :return: <Element 'para' at 0xffb37a535120>
     """
     ...
 
@@ -4810,13 +3897,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(
@@ -4834,22 +3917,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(
@@ -4910,13 +3985,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(
@@ -5019,31 +4090,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__(
@@ -5077,13 +4136,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(
@@ -5094,13 +4149,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
@@ -5153,13 +4204,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__(
@@ -5172,13 +4219,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(
@@ -5196,13 +4239,9 @@ None( (placo.JointSpaceHalfSpacesConstraint)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -5212,13 +4251,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__(
@@ -5229,13 +4264,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(
@@ -5280,13 +4311,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -5342,13 +4369,9 @@ class KinematicsConstraint:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -5358,13 +4381,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__(
@@ -5678,13 +4697,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(
@@ -5733,13 +4748,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(
@@ -5764,22 +4775,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(
@@ -5814,13 +4817,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__(
@@ -5828,13 +4827,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(
@@ -5868,13 +4863,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -5934,14 +4925,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,
@@ -5971,31 +4955,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,
@@ -6003,41 +4966,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,
@@ -6100,13 +5035,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__(
@@ -6119,31 +5050,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(
@@ -6156,49 +5075,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(
@@ -6211,13 +5110,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__(
@@ -6228,13 +5123,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(
@@ -6269,39 +5160,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6319,22 +5191,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__(
@@ -6347,13 +5211,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(
@@ -6387,31 +5247,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6429,13 +5277,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__(
@@ -6448,22 +5292,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(
@@ -6471,49 +5307,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.
   """
 
 
@@ -6553,13 +5369,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
@@ -6591,13 +5403,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__(
@@ -6610,13 +5418,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(
@@ -6650,31 +5454,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6682,13 +5474,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(
@@ -6721,13 +5509,9 @@ class Prioritized:
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -6788,13 +5572,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(
@@ -6802,76 +5582,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(
@@ -6882,22 +5630,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.
   """
 
 
@@ -6922,40 +5662,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)
   """
 
 
@@ -6997,58 +5721,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.
   """
 
 
@@ -7069,13 +5769,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__(
@@ -7083,13 +5779,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(
@@ -7123,13 +5815,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -7148,13 +5836,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,
@@ -7195,22 +5876,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__(
@@ -7224,13 +5897,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(
@@ -7264,40 +5933,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -7315,13 +5968,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__(
@@ -7335,13 +5984,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(
@@ -7375,40 +6020,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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -7416,13 +6045,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(
@@ -7467,13 +6092,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(
@@ -7514,7 +6135,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     """
     Computes all minimum distances between current collision pairs.
     
-    :return: <Element 'para' at 0xffa07c95c860>
+    :return: <Element 'para' at 0xffb37a540ef0>
     """
     ...
 
@@ -7527,7 +6148,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     Frame jacobian, default reference is LOCAL_WORLD_ALIGNED.
     
     :param any frame: the frame for which we want the jacobian 
-    :return: <Element 'para' at 0xffa07c90f420>
+    :return: <Element 'para' at 0xffb37a541620>
     """
     ...
 
@@ -7540,7 +6161,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     Jacobian time variation $\dot J$, default reference is LOCAL_WORLD_ALIGNED.
     
     :param any frame: the frame for which we want the jacobian time variation 
-    :return: <Element 'para' at 0xffa07c90dda0>
+    :return: <Element 'para' at 0xffb37a5431f0>
     """
     ...
 
@@ -7724,13 +6345,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(
@@ -7778,7 +6395,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.Model :
     Finds the self collision in current state, if stop_at_first is true, it will stop at the first collision found.
     
     :param bool stop_at_first: whether to stop at the first collision found 
-    :return: <Element 'para' at 0xffa07c95d1c0>
+    :return: <Element 'para' at 0xffb37a5406d0>
     """
     ...
 
@@ -7926,13 +6543,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(
@@ -7988,13 +6601,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.
   """
 
 
@@ -8004,31 +6613,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$
   """
 
 
@@ -8038,14 +6635,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,
@@ -8148,14 +6738,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:
@@ -8189,13 +6772,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(
@@ -8213,22 +6792,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.
   """
 
 
@@ -8244,23 +6815,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,
@@ -8273,14 +6830,7 @@ None( (placo.Support)arg1) -> bool :
     """
     ...
 
-  footsteps: any
-  """
-  
-None( (placo.Support)arg1) -> object :
-
-    C++ signature :
-        std::vector<placo::humanoid::FootstepsPlanner::Footstep, std::allocator<placo::humanoid::FootstepsPlanner::Footstep> > {lvalue} None(placo::humanoid::FootstepsPlanner::Support {lvalue})
-  """
+  footsteps: list[Footstep] # std::vector<placo::humanoid::FootstepsPlanner::Footstep>
 
   def frame(
     self,
@@ -8318,46 +6868,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:
@@ -8506,26 +7028,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(
@@ -8559,13 +7073,9 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str
@@ -8592,58 +7102,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.
   """
 
 
@@ -8669,31 +7155,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.
   """
 
 
@@ -8716,14 +7190,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,
@@ -8875,28 +7342,14 @@ None( (placo.WPGTrajectory)arg1) -> float :
   ) -> numpy.ndarray:
     ...
 
-  parts: any
-  """
-  
-None( (placo.WPGTrajectory)arg1) -> object :
-
-    C++ signature :
-        std::vector<placo::humanoid::WalkPatternGenerator::TrajectoryPart, std::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,
@@ -8910,41 +7363,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:
@@ -8955,32 +7380,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:
@@ -9058,23 +7462,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,
@@ -9103,14 +7493,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:
@@ -9119,32 +7502,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,
@@ -9158,14 +7520,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,
@@ -9181,59 +7536,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,
@@ -9251,22 +7564,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__(
@@ -9280,13 +7585,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(
@@ -9320,31 +7621,19 @@ None( (placo.Task)arg1) -> object :
     """
     ...
 
-  joint: any
+  joint: str # std::string
   """
-  
-None( (placo.WheelTask)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::kinematics::WheelTask {lvalue})
+  Frame.
   """
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::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
@@ -9352,13 +7641,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(
@@ -9382,13 +7667,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(
@@ -9406,13 +7687,9 @@ None( (placo.YawConstraint)arg1) -> float :
     """
     ...
 
-  name: any
+  name: str # std::string
   """
-  
-None( (placo.Prioritized)arg1) -> str :
-
-    C++ signature :
-        std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > {lvalue} None(placo::tools::Prioritized {lvalue})
+  Object name.
   """
 
   priority: str