PyPI - placo - Versions diffs - 0.9.5__0-cp312-cp312-manylinux_2_28_aarch64.whl → 0.9.7__0-cp312-cp312-manylinux_2_28_aarch64.whl - Mend

placo 0.9.5__0-cp312-cp312-manylinux_2_28_aarch64.whl → 0.9.7__0-cp312-cp312-manylinux_2_28_aarch64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of placo might be problematic. Click here for more details.

Files changed (9) hide show

cmeel.prefix/lib/liblibplaco.so +0 -0
cmeel.prefix/lib/python3.12/site-packages/placo.pyi +726 -2464
cmeel.prefix/lib/python3.12/site-packages/placo.so +0 -0
{placo-0.9.5.dist-info → placo-0.9.7.dist-info}/METADATA +2 -2
placo-0.9.7.dist-info/RECORD +12 -0
placo-0.9.5.dist-info/RECORD +0 -12
{placo-0.9.5.dist-info → placo-0.9.7.dist-info}/WHEEL +0 -0
{placo-0.9.5.dist-info → placo-0.9.7.dist-info}/licenses/LICENSE +0 -0
{placo-0.9.5.dist-info → placo-0.9.7.dist-info}/top_level.txt +0 -0

cmeel.prefix/lib/python3.12/site-packages/placo.pyi CHANGED Viewed

@@ -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,14 @@ None( (placo.DummyWalk)arg1) -> object :
   ) -> any:
     ...
-  feet_spacing: any
+  feet_spacing: float # double
   """
-None( (placo.DummyWalk)arg1) -> float :
-    C++ signature :
-        double {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  Feet spacing [m].
   """
-  lift_height: any
+  lift_height: float # double
   """
-None( (placo.DummyWalk)arg1) -> float :
-    C++ signature :
-        double {lvalue} None(placo::humanoid::DummyWalk {lvalue})
+  Lift height [m].
   """
   def next_step(
@@ -1401,49 +1105,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 +1152,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 +1163,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 +1183,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 +1228,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 +1254,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 +1267,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 +1302,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 +1327,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 +1347,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 +1394,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 +1404,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 +1424,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 +1445,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 +1496,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 +1513,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 +1533,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 +1580,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 +1592,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 +1612,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 +1662,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 +1705,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 +1723,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 +1743,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 +1790,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 +1803,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 +1823,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 +1868,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 +2127,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 +2181,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 +2192,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 +2206,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 +2242,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 +2288,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 +2300,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: bool # bool
-  success: any
-  """
-None( (placo.DynamicsSolverResult)arg1) -> bool :
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::DynamicsSolver::Result {lvalue})
-  """
-  tau: 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: 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: numpy.ndarray # Eigen::VectorXd
   def tau_dict(
     arg1: DynamicsSolverResult,
@@ -2989,26 +2316,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 +2345,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 +2377,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 +2387,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 +2407,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 +2467,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 +2477,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 +2608,38 @@ class ExternalWrenchContact:
     """
     ...
-  active: any
-  """
-None( (placo.Contact)arg1) -> bool :
-    C++ signature :
-        bool {lvalue} None(placo::dynamics::Contact {lvalue})
-  """
-  frame_index: any
+  active: bool # bool
   """
-None( (placo.ExternalWrenchContact)arg1) -> int :
-    C++ signature :
-        unsigned long {lvalue} None(placo::dynamics::ExternalWrenchContact {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
-  """
-None( (placo.Contact)arg1) -> float :
+  frame_index: any # pinocchio::FrameIndex
-    C++ signature :
-        double {lvalue} None(placo::dynamics::Contact {lvalue})
+  mu: float # double
   """
-  w_ext: any
+  Coefficient of friction (if relevant)
   """
-None( (placo.ExternalWrenchContact)arg1) -> object :
-    C++ signature :
-        Eigen::Matrix<double, -1, 1, 0, -1, 1> {lvalue} None(placo::dynamics::ExternalWrenchContact {lvalue})
-  """
+  w_ext: numpy.ndarray # Eigen::VectorXd
-  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.
   """
@@ -3512,32 +2737,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,
@@ -3561,14 +2765,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,
@@ -3797,13 +2994,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,
@@ -3842,13 +3032,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__(
@@ -3874,13 +3060,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(
@@ -3914,13 +3096,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
@@ -3958,14 +3136,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,
@@ -3975,13 +3146,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(
@@ -4009,49 +3176,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(
@@ -4062,40 +3209,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(
@@ -4106,13 +3234,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(
@@ -4123,103 +3247,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.
   """
@@ -4249,13 +3329,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(
@@ -4309,7 +3385,7 @@ None( (placo.HumanoidRobot)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryM
     """
     Computes all minimum distances between current collision pairs.
-    :return: <Element 'para' at 0xffd1adccc360>
+    :return: <Element 'para' at 0xff1e452b4360>
     """
     ...
@@ -4341,7 +3417,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 0xffd1adcccdb0>
+    :return: <Element 'para' at 0xff1e452b4db0>
     """
     ...
@@ -4354,7 +3430,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 0xffd1adcce480>
+    :return: <Element 'para' at 0xff1e452b6480>
     """
     ...
@@ -4599,13 +3675,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(
@@ -4660,7 +3732,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 0xffd1adcdbba0>
+    :return: <Element 'para' at 0xff1e452d3ba0>
     """
     ...
@@ -4814,13 +3886,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(
@@ -4838,22 +3906,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(
@@ -4914,13 +3974,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(
@@ -5027,31 +4083,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__(
@@ -5085,13 +4129,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(
@@ -5102,13 +4142,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
@@ -5161,13 +4197,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__(
@@ -5180,13 +4212,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(
@@ -5204,13 +4232,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
@@ -5220,13 +4244,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__(
@@ -5237,13 +4257,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(
@@ -5288,13 +4304,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
@@ -5350,13 +4362,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
@@ -5366,13 +4374,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__(
@@ -5686,13 +4690,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(
@@ -5741,13 +4741,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(
@@ -5772,22 +4768,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(
@@ -5822,13 +4810,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__(
@@ -5836,13 +4820,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(
@@ -5876,13 +4856,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
@@ -5942,14 +4918,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,
@@ -5979,31 +4948,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,
@@ -6011,41 +4959,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,
@@ -6108,13 +5028,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__(
@@ -6127,31 +5043,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(
@@ -6164,49 +5068,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(
@@ -6219,13 +5103,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__(
@@ -6236,13 +5116,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(
@@ -6277,39 +5153,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
@@ -6327,22 +5184,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__(
@@ -6355,13 +5204,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(
@@ -6395,31 +5240,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
@@ -6437,13 +5270,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__(
@@ -6456,22 +5285,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(
@@ -6479,49 +5300,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.
   """
@@ -6561,13 +5362,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
@@ -6599,13 +5396,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__(
@@ -6618,13 +5411,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(
@@ -6658,31 +5447,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
@@ -6690,13 +5467,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(
@@ -6729,13 +5502,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
@@ -6796,13 +5565,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(
@@ -6810,76 +5575,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(
@@ -6890,22 +5623,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.
   """
@@ -6930,40 +5655,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)
   """
@@ -7005,58 +5714,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.
   """
@@ -7077,13 +5762,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__(
@@ -7091,13 +5772,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(
@@ -7131,13 +5808,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
@@ -7156,13 +5829,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,
@@ -7203,22 +5869,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__(
@@ -7232,13 +5890,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(
@@ -7272,40 +5926,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
@@ -7323,13 +5961,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__(
@@ -7343,13 +5977,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(
@@ -7383,40 +6013,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
@@ -7424,13 +6038,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(
@@ -7475,13 +6085,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(
@@ -7522,7 +6128,7 @@ None( (placo.RobotWrapper)arg1) -> pinocchio.pinocchio_pywrap_default.GeometryMo
     """
     Computes all minimum distances between current collision pairs.
-    :return: <Element 'para' at 0xffd1adcce610>
+    :return: <Element 'para' at 0xff1e452b6610>
     """
     ...
@@ -7535,7 +6141,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 0xffd1add78db0>
+    :return: <Element 'para' at 0xff1e453a4db0>
     """
     ...
@@ -7548,7 +6154,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 0xffd1add7a200>
+    :return: <Element 'para' at 0xff1e453a6200>
     """
     ...
@@ -7732,13 +6338,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(
@@ -7786,7 +6388,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 0xffd1adccf790>
+    :return: <Element 'para' at 0xff1e452b7790>
     """
     ...
@@ -7934,13 +6536,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(
@@ -7996,13 +6594,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.
   """
@@ -8012,31 +6606,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$
   """
@@ -8046,14 +6628,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,
@@ -8156,14 +6731,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:
@@ -8197,13 +6765,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(
@@ -8221,22 +6785,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.
   """
@@ -8252,23 +6808,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,
@@ -8281,14 +6823,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,
@@ -8326,46 +6861,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:
@@ -8514,26 +7021,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(
@@ -8567,13 +7066,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
@@ -8600,58 +7095,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.
   """
@@ -8677,31 +7148,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.
   """
@@ -8724,14 +7183,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,
@@ -8883,28 +7335,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,
@@ -8918,41 +7356,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:
@@ -8963,32 +7373,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:
@@ -9066,23 +7455,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,
@@ -9111,14 +7486,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:
@@ -9127,32 +7495,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,
@@ -9166,14 +7513,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,
@@ -9189,59 +7529,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,
@@ -9259,22 +7557,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__(
@@ -9288,13 +7578,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(
@@ -9328,31 +7614,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
@@ -9360,13 +7634,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(
@@ -9390,13 +7660,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(
@@ -9414,13 +7680,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