agx-openplx 0.15.6__cp39-cp39-win_amd64.whl → 0.15.7__cp39-cp39-win_amd64.whl

openplx/DriveTrain.py

@@ -4070,6 +4070,646 @@ class DriveTrain_Shaft_Vector(object):
 # Register DriveTrain_Shaft_Vector in _DriveTrainSwig:
 _DriveTrainSwig.DriveTrain_Shaft_Vector_swigregister(DriveTrain_Shaft_Vector)
 
+class DriveTrain_Signals_TorqueConverterLockUpInput_Vector(object):
+    r"""Proxy of C++ std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > > class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        r"""iterator(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> SwigPyIterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        r"""__nonzero__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> bool"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___nonzero__(self)
+
+    def __bool__(self):
+        r"""__bool__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> bool"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___bool__(self)
+
+    def __len__(self):
+        r"""__len__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___len__(self)
+
+    def __getslice__(self, i, j):
+        r"""
+        __getslice__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type j) -> DriveTrain_Signals_TorqueConverterLockUpInput_Vector
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+        j: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        r"""
+        __setslice__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type j)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+        j: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+
+        __setslice__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type j, DriveTrain_Signals_TorqueConverterLockUpInput_Vector v)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+        j: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+        v: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput >,std::allocator< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > > > const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        r"""
+        __delslice__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type j)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+        j: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        r"""
+        __delitem__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type i)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+
+        __delitem__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, PySliceObject * slice)
+
+        Parameters
+        ----------
+        slice: PySliceObject *
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        r"""
+        __getitem__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, PySliceObject * slice) -> DriveTrain_Signals_TorqueConverterLockUpInput_Vector
+
+        Parameters
+        ----------
+        slice: PySliceObject *
+
+        __getitem__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type i) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        r"""
+        __setitem__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, PySliceObject * slice, DriveTrain_Signals_TorqueConverterLockUpInput_Vector v)
+
+        Parameters
+        ----------
+        slice: PySliceObject *
+        v: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput >,std::allocator< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > > > const &
+
+        __setitem__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, PySliceObject * slice)
+
+        Parameters
+        ----------
+        slice: PySliceObject *
+
+        __setitem__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const & x)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::difference_type
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector___setitem__(self, *args)
+
+    def pop(self):
+        r"""pop(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_pop(self)
+
+    def append(self, x):
+        r"""
+        append(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const & x)
+
+        Parameters
+        ----------
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_append(self, x)
+
+    def empty(self):
+        r"""empty(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> bool"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_empty(self)
+
+    def size(self):
+        r"""size(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_size(self)
+
+    def swap(self, v):
+        r"""
+        swap(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, DriveTrain_Signals_TorqueConverterLockUpInput_Vector v)
+
+        Parameters
+        ----------
+        v: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > > &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_swap(self, v)
+
+    def begin(self):
+        r"""begin(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_begin(self)
+
+    def end(self):
+        r"""end(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_end(self)
+
+    def rbegin(self):
+        r"""rbegin(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::reverse_iterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_rbegin(self)
+
+    def rend(self):
+        r"""rend(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::reverse_iterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_rend(self)
+
+    def clear(self):
+        r"""clear(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self)"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_clear(self)
+
+    def get_allocator(self):
+        r"""get_allocator(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::allocator_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_get_allocator(self)
+
+    def pop_back(self):
+        r"""pop_back(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self)"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_pop_back(self)
+
+    def erase(self, *args):
+        r"""
+        erase(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator pos) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator
+
+        Parameters
+        ----------
+        pos: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator
+
+        erase(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator first, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator last) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator
+
+        Parameters
+        ----------
+        first: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator
+        last: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_erase(self, *args)
+
+    def __init__(self, *args):
+        r"""
+        __init__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> DriveTrain_Signals_TorqueConverterLockUpInput_Vector
+        __init__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, DriveTrain_Signals_TorqueConverterLockUpInput_Vector other) -> DriveTrain_Signals_TorqueConverterLockUpInput_Vector
+
+        Parameters
+        ----------
+        other: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > > const &
+
+        __init__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type size) -> DriveTrain_Signals_TorqueConverterLockUpInput_Vector
+
+        Parameters
+        ----------
+        size: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type
+
+        __init__(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type size, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const & value) -> DriveTrain_Signals_TorqueConverterLockUpInput_Vector
+
+        Parameters
+        ----------
+        size: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type
+        value: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        """
+        _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_swiginit(self, _DriveTrainSwig.new_DriveTrain_Signals_TorqueConverterLockUpInput_Vector(*args))
+
+    def push_back(self, x):
+        r"""
+        push_back(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const & x)
+
+        Parameters
+        ----------
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_push_back(self, x)
+
+    def front(self):
+        r"""front(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_front(self)
+
+    def back(self):
+        r"""back(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_back(self)
+
+    def assign(self, n, x):
+        r"""
+        assign(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type n, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const & x)
+
+        Parameters
+        ----------
+        n: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_assign(self, n, x)
+
+    def resize(self, *args):
+        r"""
+        resize(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type new_size)
+
+        Parameters
+        ----------
+        new_size: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type
+
+        resize(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type new_size, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const & x)
+
+        Parameters
+        ----------
+        new_size: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_resize(self, *args)
+
+    def insert(self, *args):
+        r"""
+        insert(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator pos, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator
+
+        Parameters
+        ----------
+        pos: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        insert(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator pos, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type n, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const & x)
+
+        Parameters
+        ----------
+        pos: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::iterator
+        n: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_insert(self, *args)
+
+    def reserve(self, n):
+        r"""
+        reserve(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type n)
+
+        Parameters
+        ----------
+        n: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_reserve(self, n)
+
+    def capacity(self):
+        r"""capacity(DriveTrain_Signals_TorqueConverterLockUpInput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput > >::size_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_capacity(self)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Signals_TorqueConverterLockUpInput_Vector
+
+# Register DriveTrain_Signals_TorqueConverterLockUpInput_Vector in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_Vector_swigregister(DriveTrain_Signals_TorqueConverterLockUpInput_Vector)
+
+class DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector(object):
+    r"""Proxy of C++ std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > > class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        r"""iterator(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> SwigPyIterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        r"""__nonzero__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> bool"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___nonzero__(self)
+
+    def __bool__(self):
+        r"""__bool__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> bool"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___bool__(self)
+
+    def __len__(self):
+        r"""__len__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___len__(self)
+
+    def __getslice__(self, i, j):
+        r"""
+        __getslice__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type j) -> DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+        j: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        r"""
+        __setslice__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type j)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+        j: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+
+        __setslice__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type j, DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector v)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+        j: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+        v: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput >,std::allocator< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > > > const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        r"""
+        __delslice__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type j)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+        j: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        r"""
+        __delitem__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type i)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+
+        __delitem__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, PySliceObject * slice)
+
+        Parameters
+        ----------
+        slice: PySliceObject *
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        r"""
+        __getitem__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, PySliceObject * slice) -> DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector
+
+        Parameters
+        ----------
+        slice: PySliceObject *
+
+        __getitem__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type i) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        r"""
+        __setitem__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, PySliceObject * slice, DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector v)
+
+        Parameters
+        ----------
+        slice: PySliceObject *
+        v: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput >,std::allocator< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > > > const &
+
+        __setitem__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, PySliceObject * slice)
+
+        Parameters
+        ----------
+        slice: PySliceObject *
+
+        __setitem__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type i, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const & x)
+
+        Parameters
+        ----------
+        i: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::difference_type
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector___setitem__(self, *args)
+
+    def pop(self):
+        r"""pop(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_pop(self)
+
+    def append(self, x):
+        r"""
+        append(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const & x)
+
+        Parameters
+        ----------
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_append(self, x)
+
+    def empty(self):
+        r"""empty(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> bool"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_empty(self)
+
+    def size(self):
+        r"""size(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_size(self)
+
+    def swap(self, v):
+        r"""
+        swap(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector v)
+
+        Parameters
+        ----------
+        v: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > > &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_swap(self, v)
+
+    def begin(self):
+        r"""begin(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_begin(self)
+
+    def end(self):
+        r"""end(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_end(self)
+
+    def rbegin(self):
+        r"""rbegin(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::reverse_iterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_rbegin(self)
+
+    def rend(self):
+        r"""rend(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::reverse_iterator"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_rend(self)
+
+    def clear(self):
+        r"""clear(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self)"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_clear(self)
+
+    def get_allocator(self):
+        r"""get_allocator(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::allocator_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_get_allocator(self)
+
+    def pop_back(self):
+        r"""pop_back(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self)"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_pop_back(self)
+
+    def erase(self, *args):
+        r"""
+        erase(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator pos) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator
+
+        Parameters
+        ----------
+        pos: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator
+
+        erase(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator first, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator last) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator
+
+        Parameters
+        ----------
+        first: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator
+        last: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_erase(self, *args)
+
+    def __init__(self, *args):
+        r"""
+        __init__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector
+        __init__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector other) -> DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector
+
+        Parameters
+        ----------
+        other: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > > const &
+
+        __init__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type size) -> DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector
+
+        Parameters
+        ----------
+        size: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type
+
+        __init__(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type size, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const & value) -> DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector
+
+        Parameters
+        ----------
+        size: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type
+        value: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        """
+        _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_swiginit(self, _DriveTrainSwig.new_DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector(*args))
+
+    def push_back(self, x):
+        r"""
+        push_back(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const & x)
+
+        Parameters
+        ----------
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_push_back(self, x)
+
+    def front(self):
+        r"""front(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_front(self)
+
+    def back(self):
+        r"""back(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_back(self)
+
+    def assign(self, n, x):
+        r"""
+        assign(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type n, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const & x)
+
+        Parameters
+        ----------
+        n: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_assign(self, n, x)
+
+    def resize(self, *args):
+        r"""
+        resize(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type new_size)
+
+        Parameters
+        ----------
+        new_size: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type
+
+        resize(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type new_size, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const & x)
+
+        Parameters
+        ----------
+        new_size: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_resize(self, *args)
+
+    def insert(self, *args):
+        r"""
+        insert(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator pos, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator
+
+        Parameters
+        ----------
+        pos: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        insert(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator pos, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type n, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const & x)
+
+        Parameters
+        ----------
+        pos: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::iterator
+        n: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type
+        x: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::value_type const &
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_insert(self, *args)
+
+    def reserve(self, n):
+        r"""
+        reserve(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self, std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type n)
+
+        Parameters
+        ----------
+        n: std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type
+
+        """
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_reserve(self, n)
+
+    def capacity(self):
+        r"""capacity(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector self) -> std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput > >::size_type"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_capacity(self)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector
+
+# Register DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector_swigregister(DriveTrain_Signals_TorqueConverterLockedUpOutput_Vector)
+
 class DriveTrain_Signals_TorqueConverterPumpTorqueOutput_Vector(object):
     r"""Proxy of C++ std::vector< std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterPumpTorqueOutput > > class."""
 
@@ -6529,11 +7169,11 @@ class AutomaticClutch(ManualClutch):
         return _DriveTrainSwig.AutomaticClutch_initially_engaged(self)
 
     def engage_input(self):
-        r"""engage_input(AutomaticClutch self) -> std::shared_ptr< openplx::Physics::Signals::BoolInput >"""
+        r"""engage_input(AutomaticClutch self) -> std::shared_ptr< openplx::Physics::Signals::EngageInput >"""
         return _DriveTrainSwig.AutomaticClutch_engage_input(self)
 
     def engaged_output(self):
-        r"""engaged_output(AutomaticClutch self) -> std::shared_ptr< openplx::Physics::Signals::BoolOutput >"""
+        r"""engaged_output(AutomaticClutch self) -> std::shared_ptr< openplx::Physics::Signals::EngagedOutput >"""
         return _DriveTrainSwig.AutomaticClutch_engaged_output(self)
 
     def setDynamic(self, key, value):
@@ -6847,11 +7487,11 @@ class EmpiricalTorqueConverter(openplx.Physics1D.Interactions_Mate):
         return _DriveTrainSwig.EmpiricalTorqueConverter_lock_up_time(self)
 
     def lock_up_input(self):
-        r"""lock_up_input(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::Physics::Signals::BoolInput >"""
+        r"""lock_up_input(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput >"""
         return _DriveTrainSwig.EmpiricalTorqueConverter_lock_up_input(self)
 
     def locked_up_output(self):
-        r"""locked_up_output(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::Physics::Signals::BoolOutput >"""
+        r"""locked_up_output(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput >"""
         return _DriveTrainSwig.EmpiricalTorqueConverter_locked_up_output(self)
 
     def velocity_ratio_torque_multiplier_list(self):
@@ -7550,6 +8190,170 @@ class Shaft(openplx.Physics1D.Bodies_RotationalBody):
 # Register Shaft in _DriveTrainSwig:
 _DriveTrainSwig.Shaft_swigregister(Shaft)
 
+class Signals_TorqueConverterLockUpInput(openplx.Physics.Signals_BoolInput):
+    r"""Proxy of C++ openplx::DriveTrain::Signals::TorqueConverterLockUpInput class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(Signals_TorqueConverterLockUpInput self) -> Signals_TorqueConverterLockUpInput"""
+        _DriveTrainSwig.Signals_TorqueConverterLockUpInput_swiginit(self, _DriveTrainSwig.new_Signals_TorqueConverterLockUpInput())
+
+    def setDynamic(self, key, value):
+        r"""
+        setDynamic(Signals_TorqueConverterLockUpInput self, std::string const & key, Any value)
+
+        Parameters
+        ----------
+        key: std::string const &
+        value: openplx::Core::Any &&
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_setDynamic(self, key, value)
+
+    def getDynamic(self, key):
+        r"""
+        getDynamic(Signals_TorqueConverterLockUpInput self, std::string const & key) -> Any
+
+        Parameters
+        ----------
+        key: std::string const &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_getDynamic(self, key)
+
+    def callDynamic(self, key, args):
+        r"""
+        callDynamic(Signals_TorqueConverterLockUpInput self, std::string const & key, AnyVector args) -> Any
+
+        Parameters
+        ----------
+        key: std::string const &
+        args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_callDynamic(self, key, args)
+
+    def extractObjectFieldsTo(self, output):
+        r"""
+        extractObjectFieldsTo(Signals_TorqueConverterLockUpInput self, ObjectVector output)
+
+        Parameters
+        ----------
+        output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_extractObjectFieldsTo(self, output)
+
+    def extractEntriesTo(self, output):
+        r"""
+        extractEntriesTo(Signals_TorqueConverterLockUpInput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+
+        Parameters
+        ----------
+        output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_extractEntriesTo(self, output)
+
+    def triggerOnInit(self, context):
+        r"""
+        triggerOnInit(Signals_TorqueConverterLockUpInput self, openplx::RuntimeContext const & context)
+
+        Parameters
+        ----------
+        context: openplx::RuntimeContext const &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_Signals_TorqueConverterLockUpInput
+
+# Register Signals_TorqueConverterLockUpInput in _DriveTrainSwig:
+_DriveTrainSwig.Signals_TorqueConverterLockUpInput_swigregister(Signals_TorqueConverterLockUpInput)
+
+class Signals_TorqueConverterLockedUpOutput(openplx.Physics.Signals_BoolOutput):
+    r"""Proxy of C++ openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(Signals_TorqueConverterLockedUpOutput self) -> Signals_TorqueConverterLockedUpOutput"""
+        _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_swiginit(self, _DriveTrainSwig.new_Signals_TorqueConverterLockedUpOutput())
+
+    def setDynamic(self, key, value):
+        r"""
+        setDynamic(Signals_TorqueConverterLockedUpOutput self, std::string const & key, Any value)
+
+        Parameters
+        ----------
+        key: std::string const &
+        value: openplx::Core::Any &&
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_setDynamic(self, key, value)
+
+    def getDynamic(self, key):
+        r"""
+        getDynamic(Signals_TorqueConverterLockedUpOutput self, std::string const & key) -> Any
+
+        Parameters
+        ----------
+        key: std::string const &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_getDynamic(self, key)
+
+    def callDynamic(self, key, args):
+        r"""
+        callDynamic(Signals_TorqueConverterLockedUpOutput self, std::string const & key, AnyVector args) -> Any
+
+        Parameters
+        ----------
+        key: std::string const &
+        args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_callDynamic(self, key, args)
+
+    def extractObjectFieldsTo(self, output):
+        r"""
+        extractObjectFieldsTo(Signals_TorqueConverterLockedUpOutput self, ObjectVector output)
+
+        Parameters
+        ----------
+        output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_extractObjectFieldsTo(self, output)
+
+    def extractEntriesTo(self, output):
+        r"""
+        extractEntriesTo(Signals_TorqueConverterLockedUpOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+
+        Parameters
+        ----------
+        output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_extractEntriesTo(self, output)
+
+    def triggerOnInit(self, context):
+        r"""
+        triggerOnInit(Signals_TorqueConverterLockedUpOutput self, openplx::RuntimeContext const & context)
+
+        Parameters
+        ----------
+        context: openplx::RuntimeContext const &
+
+        """
+        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_Signals_TorqueConverterLockedUpOutput
+
+# Register Signals_TorqueConverterLockedUpOutput in _DriveTrainSwig:
+_DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_swigregister(Signals_TorqueConverterLockedUpOutput)
+
 class Signals_TorqueConverterPumpTorqueOutput(openplx.Physics.Signals_Output):
     r"""Proxy of C++ openplx::DriveTrain::Signals::TorqueConverterPumpTorqueOutput class."""