# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _pmt_swig
else:
    import _pmt_swig

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pmt_swig.delete_SwigPyIterator

    def value(self) -> "PyObject *":
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _pmt_swig.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _pmt_swig.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pmt_swig.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _pmt_swig.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _pmt_swig.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _pmt_swig.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pmt_swig.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pmt_swig.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pmt_swig.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _pmt_swig.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _pmt_swig:
_pmt_swig.SwigPyIterator_swigregister(SwigPyIterator)

class pmt_vector_int8(object):
    r"""Proxy of C++ std::vector< int8_t > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_int8 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_int8_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_int8 self) -> bool"""
        return _pmt_swig.pmt_vector_int8___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_int8 self) -> bool"""
        return _pmt_swig.pmt_vector_int8___bool__(self)

    def __len__(self) -> "std::vector< signed char >::size_type":
        r"""__len__(pmt_vector_int8 self) -> std::vector< signed char >::size_type"""
        return _pmt_swig.pmt_vector_int8___len__(self)

    def __getslice__(self, i: "std::vector< signed char >::difference_type", j: "std::vector< signed char >::difference_type") -> "std::vector< signed char,std::allocator< signed char > > *":
        r"""__getslice__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j) -> pmt_vector_int8"""
        return _pmt_swig.pmt_vector_int8___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j)
        __setslice__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j, pmt_vector_int8 v)
        """
        return _pmt_swig.pmt_vector_int8___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< signed char >::difference_type", j: "std::vector< signed char >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j)"""
        return _pmt_swig.pmt_vector_int8___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_int8 self, std::vector< signed char >::difference_type i)
        __delitem__(pmt_vector_int8 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_int8___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< signed char >::value_type const &":
        r"""
        __getitem__(pmt_vector_int8 self, PySliceObject * slice) -> pmt_vector_int8
        __getitem__(pmt_vector_int8 self, std::vector< signed char >::difference_type i) -> std::vector< signed char >::value_type const &
        """
        return _pmt_swig.pmt_vector_int8___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_int8 self, PySliceObject * slice, pmt_vector_int8 v)
        __setitem__(pmt_vector_int8 self, PySliceObject * slice)
        __setitem__(pmt_vector_int8 self, std::vector< signed char >::difference_type i, std::vector< signed char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int8___setitem__(self, *args)

    def pop(self) -> "std::vector< signed char >::value_type":
        r"""pop(pmt_vector_int8 self) -> std::vector< signed char >::value_type"""
        return _pmt_swig.pmt_vector_int8_pop(self)

    def append(self, x: "std::vector< signed char >::value_type const &") -> "void":
        r"""append(pmt_vector_int8 self, std::vector< signed char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int8_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_int8 self) -> bool"""
        return _pmt_swig.pmt_vector_int8_empty(self)

    def size(self) -> "std::vector< signed char >::size_type":
        r"""size(pmt_vector_int8 self) -> std::vector< signed char >::size_type"""
        return _pmt_swig.pmt_vector_int8_size(self)

    def swap(self, v: "pmt_vector_int8") -> "void":
        r"""swap(pmt_vector_int8 self, pmt_vector_int8 v)"""
        return _pmt_swig.pmt_vector_int8_swap(self, v)

    def begin(self) -> "std::vector< signed char >::iterator":
        r"""begin(pmt_vector_int8 self) -> std::vector< signed char >::iterator"""
        return _pmt_swig.pmt_vector_int8_begin(self)

    def end(self) -> "std::vector< signed char >::iterator":
        r"""end(pmt_vector_int8 self) -> std::vector< signed char >::iterator"""
        return _pmt_swig.pmt_vector_int8_end(self)

    def rbegin(self) -> "std::vector< signed char >::reverse_iterator":
        r"""rbegin(pmt_vector_int8 self) -> std::vector< signed char >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int8_rbegin(self)

    def rend(self) -> "std::vector< signed char >::reverse_iterator":
        r"""rend(pmt_vector_int8 self) -> std::vector< signed char >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int8_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_int8 self)"""
        return _pmt_swig.pmt_vector_int8_clear(self)

    def get_allocator(self) -> "std::vector< signed char >::allocator_type":
        r"""get_allocator(pmt_vector_int8 self) -> std::vector< signed char >::allocator_type"""
        return _pmt_swig.pmt_vector_int8_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_int8 self)"""
        return _pmt_swig.pmt_vector_int8_pop_back(self)

    def erase(self, *args) -> "std::vector< signed char >::iterator":
        r"""
        erase(pmt_vector_int8 self, std::vector< signed char >::iterator pos) -> std::vector< signed char >::iterator
        erase(pmt_vector_int8 self, std::vector< signed char >::iterator first, std::vector< signed char >::iterator last) -> std::vector< signed char >::iterator
        """
        return _pmt_swig.pmt_vector_int8_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_int8 self) -> pmt_vector_int8
        __init__(pmt_vector_int8 self, pmt_vector_int8 other) -> pmt_vector_int8
        __init__(pmt_vector_int8 self, std::vector< signed char >::size_type size) -> pmt_vector_int8
        __init__(pmt_vector_int8 self, std::vector< signed char >::size_type size, std::vector< signed char >::value_type const & value) -> pmt_vector_int8
        """
        _pmt_swig.pmt_vector_int8_swiginit(self, _pmt_swig.new_pmt_vector_int8(*args))

    def push_back(self, x: "std::vector< signed char >::value_type const &") -> "void":
        r"""push_back(pmt_vector_int8 self, std::vector< signed char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int8_push_back(self, x)

    def front(self) -> "std::vector< signed char >::value_type const &":
        r"""front(pmt_vector_int8 self) -> std::vector< signed char >::value_type const &"""
        return _pmt_swig.pmt_vector_int8_front(self)

    def back(self) -> "std::vector< signed char >::value_type const &":
        r"""back(pmt_vector_int8 self) -> std::vector< signed char >::value_type const &"""
        return _pmt_swig.pmt_vector_int8_back(self)

    def assign(self, n: "std::vector< signed char >::size_type", x: "std::vector< signed char >::value_type const &") -> "void":
        r"""assign(pmt_vector_int8 self, std::vector< signed char >::size_type n, std::vector< signed char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int8_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_int8 self, std::vector< signed char >::size_type new_size)
        resize(pmt_vector_int8 self, std::vector< signed char >::size_type new_size, std::vector< signed char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int8_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_int8 self, std::vector< signed char >::iterator pos, std::vector< signed char >::value_type const & x) -> std::vector< signed char >::iterator
        insert(pmt_vector_int8 self, std::vector< signed char >::iterator pos, std::vector< signed char >::size_type n, std::vector< signed char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int8_insert(self, *args)

    def reserve(self, n: "std::vector< signed char >::size_type") -> "void":
        r"""reserve(pmt_vector_int8 self, std::vector< signed char >::size_type n)"""
        return _pmt_swig.pmt_vector_int8_reserve(self, n)

    def capacity(self) -> "std::vector< signed char >::size_type":
        r"""capacity(pmt_vector_int8 self) -> std::vector< signed char >::size_type"""
        return _pmt_swig.pmt_vector_int8_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_int8

# Register pmt_vector_int8 in _pmt_swig:
_pmt_swig.pmt_vector_int8_swigregister(pmt_vector_int8)

class pmt_vector_uint8(object):
    r"""Proxy of C++ std::vector< uint8_t > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_uint8 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_uint8_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_uint8 self) -> bool"""
        return _pmt_swig.pmt_vector_uint8___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_uint8 self) -> bool"""
        return _pmt_swig.pmt_vector_uint8___bool__(self)

    def __len__(self) -> "std::vector< unsigned char >::size_type":
        r"""__len__(pmt_vector_uint8 self) -> std::vector< unsigned char >::size_type"""
        return _pmt_swig.pmt_vector_uint8___len__(self)

    def __getslice__(self, i: "std::vector< unsigned char >::difference_type", j: "std::vector< unsigned char >::difference_type") -> "std::vector< unsigned char,std::allocator< unsigned char > > *":
        r"""__getslice__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j) -> pmt_vector_uint8"""
        return _pmt_swig.pmt_vector_uint8___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)
        __setslice__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j, pmt_vector_uint8 v)
        """
        return _pmt_swig.pmt_vector_uint8___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< unsigned char >::difference_type", j: "std::vector< unsigned char >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)"""
        return _pmt_swig.pmt_vector_uint8___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i)
        __delitem__(pmt_vector_uint8 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_uint8___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< unsigned char >::value_type const &":
        r"""
        __getitem__(pmt_vector_uint8 self, PySliceObject * slice) -> pmt_vector_uint8
        __getitem__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i) -> std::vector< unsigned char >::value_type const &
        """
        return _pmt_swig.pmt_vector_uint8___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_uint8 self, PySliceObject * slice, pmt_vector_uint8 v)
        __setitem__(pmt_vector_uint8 self, PySliceObject * slice)
        __setitem__(pmt_vector_uint8 self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint8___setitem__(self, *args)

    def pop(self) -> "std::vector< unsigned char >::value_type":
        r"""pop(pmt_vector_uint8 self) -> std::vector< unsigned char >::value_type"""
        return _pmt_swig.pmt_vector_uint8_pop(self)

    def append(self, x: "std::vector< unsigned char >::value_type const &") -> "void":
        r"""append(pmt_vector_uint8 self, std::vector< unsigned char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint8_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_uint8 self) -> bool"""
        return _pmt_swig.pmt_vector_uint8_empty(self)

    def size(self) -> "std::vector< unsigned char >::size_type":
        r"""size(pmt_vector_uint8 self) -> std::vector< unsigned char >::size_type"""
        return _pmt_swig.pmt_vector_uint8_size(self)

    def swap(self, v: "pmt_vector_uint8") -> "void":
        r"""swap(pmt_vector_uint8 self, pmt_vector_uint8 v)"""
        return _pmt_swig.pmt_vector_uint8_swap(self, v)

    def begin(self) -> "std::vector< unsigned char >::iterator":
        r"""begin(pmt_vector_uint8 self) -> std::vector< unsigned char >::iterator"""
        return _pmt_swig.pmt_vector_uint8_begin(self)

    def end(self) -> "std::vector< unsigned char >::iterator":
        r"""end(pmt_vector_uint8 self) -> std::vector< unsigned char >::iterator"""
        return _pmt_swig.pmt_vector_uint8_end(self)

    def rbegin(self) -> "std::vector< unsigned char >::reverse_iterator":
        r"""rbegin(pmt_vector_uint8 self) -> std::vector< unsigned char >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint8_rbegin(self)

    def rend(self) -> "std::vector< unsigned char >::reverse_iterator":
        r"""rend(pmt_vector_uint8 self) -> std::vector< unsigned char >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint8_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_uint8 self)"""
        return _pmt_swig.pmt_vector_uint8_clear(self)

    def get_allocator(self) -> "std::vector< unsigned char >::allocator_type":
        r"""get_allocator(pmt_vector_uint8 self) -> std::vector< unsigned char >::allocator_type"""
        return _pmt_swig.pmt_vector_uint8_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_uint8 self)"""
        return _pmt_swig.pmt_vector_uint8_pop_back(self)

    def erase(self, *args) -> "std::vector< unsigned char >::iterator":
        r"""
        erase(pmt_vector_uint8 self, std::vector< unsigned char >::iterator pos) -> std::vector< unsigned char >::iterator
        erase(pmt_vector_uint8 self, std::vector< unsigned char >::iterator first, std::vector< unsigned char >::iterator last) -> std::vector< unsigned char >::iterator
        """
        return _pmt_swig.pmt_vector_uint8_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_uint8 self) -> pmt_vector_uint8
        __init__(pmt_vector_uint8 self, pmt_vector_uint8 other) -> pmt_vector_uint8
        __init__(pmt_vector_uint8 self, std::vector< unsigned char >::size_type size) -> pmt_vector_uint8
        __init__(pmt_vector_uint8 self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> pmt_vector_uint8
        """
        _pmt_swig.pmt_vector_uint8_swiginit(self, _pmt_swig.new_pmt_vector_uint8(*args))

    def push_back(self, x: "std::vector< unsigned char >::value_type const &") -> "void":
        r"""push_back(pmt_vector_uint8 self, std::vector< unsigned char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint8_push_back(self, x)

    def front(self) -> "std::vector< unsigned char >::value_type const &":
        r"""front(pmt_vector_uint8 self) -> std::vector< unsigned char >::value_type const &"""
        return _pmt_swig.pmt_vector_uint8_front(self)

    def back(self) -> "std::vector< unsigned char >::value_type const &":
        r"""back(pmt_vector_uint8 self) -> std::vector< unsigned char >::value_type const &"""
        return _pmt_swig.pmt_vector_uint8_back(self)

    def assign(self, n: "std::vector< unsigned char >::size_type", x: "std::vector< unsigned char >::value_type const &") -> "void":
        r"""assign(pmt_vector_uint8 self, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint8_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_uint8 self, std::vector< unsigned char >::size_type new_size)
        resize(pmt_vector_uint8 self, std::vector< unsigned char >::size_type new_size, std::vector< unsigned char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint8_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_uint8 self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::value_type const & x) -> std::vector< unsigned char >::iterator
        insert(pmt_vector_uint8 self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint8_insert(self, *args)

    def reserve(self, n: "std::vector< unsigned char >::size_type") -> "void":
        r"""reserve(pmt_vector_uint8 self, std::vector< unsigned char >::size_type n)"""
        return _pmt_swig.pmt_vector_uint8_reserve(self, n)

    def capacity(self) -> "std::vector< unsigned char >::size_type":
        r"""capacity(pmt_vector_uint8 self) -> std::vector< unsigned char >::size_type"""
        return _pmt_swig.pmt_vector_uint8_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_uint8

# Register pmt_vector_uint8 in _pmt_swig:
_pmt_swig.pmt_vector_uint8_swigregister(pmt_vector_uint8)

class pmt_vector_int16(object):
    r"""Proxy of C++ std::vector< int16_t > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_int16 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_int16_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_int16 self) -> bool"""
        return _pmt_swig.pmt_vector_int16___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_int16 self) -> bool"""
        return _pmt_swig.pmt_vector_int16___bool__(self)

    def __len__(self) -> "std::vector< short >::size_type":
        r"""__len__(pmt_vector_int16 self) -> std::vector< short >::size_type"""
        return _pmt_swig.pmt_vector_int16___len__(self)

    def __getslice__(self, i: "std::vector< short >::difference_type", j: "std::vector< short >::difference_type") -> "std::vector< short,std::allocator< short > > *":
        r"""__getslice__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j) -> pmt_vector_int16"""
        return _pmt_swig.pmt_vector_int16___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)
        __setslice__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j, pmt_vector_int16 v)
        """
        return _pmt_swig.pmt_vector_int16___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< short >::difference_type", j: "std::vector< short >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)"""
        return _pmt_swig.pmt_vector_int16___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_int16 self, std::vector< short >::difference_type i)
        __delitem__(pmt_vector_int16 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_int16___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< short >::value_type const &":
        r"""
        __getitem__(pmt_vector_int16 self, PySliceObject * slice) -> pmt_vector_int16
        __getitem__(pmt_vector_int16 self, std::vector< short >::difference_type i) -> std::vector< short >::value_type const &
        """
        return _pmt_swig.pmt_vector_int16___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_int16 self, PySliceObject * slice, pmt_vector_int16 v)
        __setitem__(pmt_vector_int16 self, PySliceObject * slice)
        __setitem__(pmt_vector_int16 self, std::vector< short >::difference_type i, std::vector< short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int16___setitem__(self, *args)

    def pop(self) -> "std::vector< short >::value_type":
        r"""pop(pmt_vector_int16 self) -> std::vector< short >::value_type"""
        return _pmt_swig.pmt_vector_int16_pop(self)

    def append(self, x: "std::vector< short >::value_type const &") -> "void":
        r"""append(pmt_vector_int16 self, std::vector< short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int16_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_int16 self) -> bool"""
        return _pmt_swig.pmt_vector_int16_empty(self)

    def size(self) -> "std::vector< short >::size_type":
        r"""size(pmt_vector_int16 self) -> std::vector< short >::size_type"""
        return _pmt_swig.pmt_vector_int16_size(self)

    def swap(self, v: "pmt_vector_int16") -> "void":
        r"""swap(pmt_vector_int16 self, pmt_vector_int16 v)"""
        return _pmt_swig.pmt_vector_int16_swap(self, v)

    def begin(self) -> "std::vector< short >::iterator":
        r"""begin(pmt_vector_int16 self) -> std::vector< short >::iterator"""
        return _pmt_swig.pmt_vector_int16_begin(self)

    def end(self) -> "std::vector< short >::iterator":
        r"""end(pmt_vector_int16 self) -> std::vector< short >::iterator"""
        return _pmt_swig.pmt_vector_int16_end(self)

    def rbegin(self) -> "std::vector< short >::reverse_iterator":
        r"""rbegin(pmt_vector_int16 self) -> std::vector< short >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int16_rbegin(self)

    def rend(self) -> "std::vector< short >::reverse_iterator":
        r"""rend(pmt_vector_int16 self) -> std::vector< short >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int16_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_int16 self)"""
        return _pmt_swig.pmt_vector_int16_clear(self)

    def get_allocator(self) -> "std::vector< short >::allocator_type":
        r"""get_allocator(pmt_vector_int16 self) -> std::vector< short >::allocator_type"""
        return _pmt_swig.pmt_vector_int16_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_int16 self)"""
        return _pmt_swig.pmt_vector_int16_pop_back(self)

    def erase(self, *args) -> "std::vector< short >::iterator":
        r"""
        erase(pmt_vector_int16 self, std::vector< short >::iterator pos) -> std::vector< short >::iterator
        erase(pmt_vector_int16 self, std::vector< short >::iterator first, std::vector< short >::iterator last) -> std::vector< short >::iterator
        """
        return _pmt_swig.pmt_vector_int16_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_int16 self) -> pmt_vector_int16
        __init__(pmt_vector_int16 self, pmt_vector_int16 other) -> pmt_vector_int16
        __init__(pmt_vector_int16 self, std::vector< short >::size_type size) -> pmt_vector_int16
        __init__(pmt_vector_int16 self, std::vector< short >::size_type size, std::vector< short >::value_type const & value) -> pmt_vector_int16
        """
        _pmt_swig.pmt_vector_int16_swiginit(self, _pmt_swig.new_pmt_vector_int16(*args))

    def push_back(self, x: "std::vector< short >::value_type const &") -> "void":
        r"""push_back(pmt_vector_int16 self, std::vector< short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int16_push_back(self, x)

    def front(self) -> "std::vector< short >::value_type const &":
        r"""front(pmt_vector_int16 self) -> std::vector< short >::value_type const &"""
        return _pmt_swig.pmt_vector_int16_front(self)

    def back(self) -> "std::vector< short >::value_type const &":
        r"""back(pmt_vector_int16 self) -> std::vector< short >::value_type const &"""
        return _pmt_swig.pmt_vector_int16_back(self)

    def assign(self, n: "std::vector< short >::size_type", x: "std::vector< short >::value_type const &") -> "void":
        r"""assign(pmt_vector_int16 self, std::vector< short >::size_type n, std::vector< short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int16_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_int16 self, std::vector< short >::size_type new_size)
        resize(pmt_vector_int16 self, std::vector< short >::size_type new_size, std::vector< short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int16_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_int16 self, std::vector< short >::iterator pos, std::vector< short >::value_type const & x) -> std::vector< short >::iterator
        insert(pmt_vector_int16 self, std::vector< short >::iterator pos, std::vector< short >::size_type n, std::vector< short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int16_insert(self, *args)

    def reserve(self, n: "std::vector< short >::size_type") -> "void":
        r"""reserve(pmt_vector_int16 self, std::vector< short >::size_type n)"""
        return _pmt_swig.pmt_vector_int16_reserve(self, n)

    def capacity(self) -> "std::vector< short >::size_type":
        r"""capacity(pmt_vector_int16 self) -> std::vector< short >::size_type"""
        return _pmt_swig.pmt_vector_int16_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_int16

# Register pmt_vector_int16 in _pmt_swig:
_pmt_swig.pmt_vector_int16_swigregister(pmt_vector_int16)

class pmt_vector_uint16(object):
    r"""Proxy of C++ std::vector< uint16_t > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_uint16 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_uint16_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_uint16 self) -> bool"""
        return _pmt_swig.pmt_vector_uint16___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_uint16 self) -> bool"""
        return _pmt_swig.pmt_vector_uint16___bool__(self)

    def __len__(self) -> "std::vector< unsigned short >::size_type":
        r"""__len__(pmt_vector_uint16 self) -> std::vector< unsigned short >::size_type"""
        return _pmt_swig.pmt_vector_uint16___len__(self)

    def __getslice__(self, i: "std::vector< unsigned short >::difference_type", j: "std::vector< unsigned short >::difference_type") -> "std::vector< unsigned short,std::allocator< unsigned short > > *":
        r"""__getslice__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j) -> pmt_vector_uint16"""
        return _pmt_swig.pmt_vector_uint16___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j)
        __setslice__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j, pmt_vector_uint16 v)
        """
        return _pmt_swig.pmt_vector_uint16___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< unsigned short >::difference_type", j: "std::vector< unsigned short >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j)"""
        return _pmt_swig.pmt_vector_uint16___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i)
        __delitem__(pmt_vector_uint16 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_uint16___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< unsigned short >::value_type const &":
        r"""
        __getitem__(pmt_vector_uint16 self, PySliceObject * slice) -> pmt_vector_uint16
        __getitem__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i) -> std::vector< unsigned short >::value_type const &
        """
        return _pmt_swig.pmt_vector_uint16___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_uint16 self, PySliceObject * slice, pmt_vector_uint16 v)
        __setitem__(pmt_vector_uint16 self, PySliceObject * slice)
        __setitem__(pmt_vector_uint16 self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint16___setitem__(self, *args)

    def pop(self) -> "std::vector< unsigned short >::value_type":
        r"""pop(pmt_vector_uint16 self) -> std::vector< unsigned short >::value_type"""
        return _pmt_swig.pmt_vector_uint16_pop(self)

    def append(self, x: "std::vector< unsigned short >::value_type const &") -> "void":
        r"""append(pmt_vector_uint16 self, std::vector< unsigned short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint16_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_uint16 self) -> bool"""
        return _pmt_swig.pmt_vector_uint16_empty(self)

    def size(self) -> "std::vector< unsigned short >::size_type":
        r"""size(pmt_vector_uint16 self) -> std::vector< unsigned short >::size_type"""
        return _pmt_swig.pmt_vector_uint16_size(self)

    def swap(self, v: "pmt_vector_uint16") -> "void":
        r"""swap(pmt_vector_uint16 self, pmt_vector_uint16 v)"""
        return _pmt_swig.pmt_vector_uint16_swap(self, v)

    def begin(self) -> "std::vector< unsigned short >::iterator":
        r"""begin(pmt_vector_uint16 self) -> std::vector< unsigned short >::iterator"""
        return _pmt_swig.pmt_vector_uint16_begin(self)

    def end(self) -> "std::vector< unsigned short >::iterator":
        r"""end(pmt_vector_uint16 self) -> std::vector< unsigned short >::iterator"""
        return _pmt_swig.pmt_vector_uint16_end(self)

    def rbegin(self) -> "std::vector< unsigned short >::reverse_iterator":
        r"""rbegin(pmt_vector_uint16 self) -> std::vector< unsigned short >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint16_rbegin(self)

    def rend(self) -> "std::vector< unsigned short >::reverse_iterator":
        r"""rend(pmt_vector_uint16 self) -> std::vector< unsigned short >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint16_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_uint16 self)"""
        return _pmt_swig.pmt_vector_uint16_clear(self)

    def get_allocator(self) -> "std::vector< unsigned short >::allocator_type":
        r"""get_allocator(pmt_vector_uint16 self) -> std::vector< unsigned short >::allocator_type"""
        return _pmt_swig.pmt_vector_uint16_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_uint16 self)"""
        return _pmt_swig.pmt_vector_uint16_pop_back(self)

    def erase(self, *args) -> "std::vector< unsigned short >::iterator":
        r"""
        erase(pmt_vector_uint16 self, std::vector< unsigned short >::iterator pos) -> std::vector< unsigned short >::iterator
        erase(pmt_vector_uint16 self, std::vector< unsigned short >::iterator first, std::vector< unsigned short >::iterator last) -> std::vector< unsigned short >::iterator
        """
        return _pmt_swig.pmt_vector_uint16_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_uint16 self) -> pmt_vector_uint16
        __init__(pmt_vector_uint16 self, pmt_vector_uint16 other) -> pmt_vector_uint16
        __init__(pmt_vector_uint16 self, std::vector< unsigned short >::size_type size) -> pmt_vector_uint16
        __init__(pmt_vector_uint16 self, std::vector< unsigned short >::size_type size, std::vector< unsigned short >::value_type const & value) -> pmt_vector_uint16
        """
        _pmt_swig.pmt_vector_uint16_swiginit(self, _pmt_swig.new_pmt_vector_uint16(*args))

    def push_back(self, x: "std::vector< unsigned short >::value_type const &") -> "void":
        r"""push_back(pmt_vector_uint16 self, std::vector< unsigned short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint16_push_back(self, x)

    def front(self) -> "std::vector< unsigned short >::value_type const &":
        r"""front(pmt_vector_uint16 self) -> std::vector< unsigned short >::value_type const &"""
        return _pmt_swig.pmt_vector_uint16_front(self)

    def back(self) -> "std::vector< unsigned short >::value_type const &":
        r"""back(pmt_vector_uint16 self) -> std::vector< unsigned short >::value_type const &"""
        return _pmt_swig.pmt_vector_uint16_back(self)

    def assign(self, n: "std::vector< unsigned short >::size_type", x: "std::vector< unsigned short >::value_type const &") -> "void":
        r"""assign(pmt_vector_uint16 self, std::vector< unsigned short >::size_type n, std::vector< unsigned short >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint16_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_uint16 self, std::vector< unsigned short >::size_type new_size)
        resize(pmt_vector_uint16 self, std::vector< unsigned short >::size_type new_size, std::vector< unsigned short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint16_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_uint16 self, std::vector< unsigned short >::iterator pos, std::vector< unsigned short >::value_type const & x) -> std::vector< unsigned short >::iterator
        insert(pmt_vector_uint16 self, std::vector< unsigned short >::iterator pos, std::vector< unsigned short >::size_type n, std::vector< unsigned short >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint16_insert(self, *args)

    def reserve(self, n: "std::vector< unsigned short >::size_type") -> "void":
        r"""reserve(pmt_vector_uint16 self, std::vector< unsigned short >::size_type n)"""
        return _pmt_swig.pmt_vector_uint16_reserve(self, n)

    def capacity(self) -> "std::vector< unsigned short >::size_type":
        r"""capacity(pmt_vector_uint16 self) -> std::vector< unsigned short >::size_type"""
        return _pmt_swig.pmt_vector_uint16_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_uint16

# Register pmt_vector_uint16 in _pmt_swig:
_pmt_swig.pmt_vector_uint16_swigregister(pmt_vector_uint16)

class pmt_vector_int32(object):
    r"""Proxy of C++ std::vector< int32_t > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_int32 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_int32_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_int32 self) -> bool"""
        return _pmt_swig.pmt_vector_int32___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_int32 self) -> bool"""
        return _pmt_swig.pmt_vector_int32___bool__(self)

    def __len__(self) -> "std::vector< int >::size_type":
        r"""__len__(pmt_vector_int32 self) -> std::vector< int >::size_type"""
        return _pmt_swig.pmt_vector_int32___len__(self)

    def __getslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "std::vector< int,std::allocator< int > > *":
        r"""__getslice__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> pmt_vector_int32"""
        return _pmt_swig.pmt_vector_int32___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, pmt_vector_int32 v)
        """
        return _pmt_swig.pmt_vector_int32___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _pmt_swig.pmt_vector_int32___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_int32 self, std::vector< int >::difference_type i)
        __delitem__(pmt_vector_int32 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_int32___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< int >::value_type const &":
        r"""
        __getitem__(pmt_vector_int32 self, PySliceObject * slice) -> pmt_vector_int32
        __getitem__(pmt_vector_int32 self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _pmt_swig.pmt_vector_int32___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_int32 self, PySliceObject * slice, pmt_vector_int32 v)
        __setitem__(pmt_vector_int32 self, PySliceObject * slice)
        __setitem__(pmt_vector_int32 self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int32___setitem__(self, *args)

    def pop(self) -> "std::vector< int >::value_type":
        r"""pop(pmt_vector_int32 self) -> std::vector< int >::value_type"""
        return _pmt_swig.pmt_vector_int32_pop(self)

    def append(self, x: "std::vector< int >::value_type const &") -> "void":
        r"""append(pmt_vector_int32 self, std::vector< int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int32_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_int32 self) -> bool"""
        return _pmt_swig.pmt_vector_int32_empty(self)

    def size(self) -> "std::vector< int >::size_type":
        r"""size(pmt_vector_int32 self) -> std::vector< int >::size_type"""
        return _pmt_swig.pmt_vector_int32_size(self)

    def swap(self, v: "pmt_vector_int32") -> "void":
        r"""swap(pmt_vector_int32 self, pmt_vector_int32 v)"""
        return _pmt_swig.pmt_vector_int32_swap(self, v)

    def begin(self) -> "std::vector< int >::iterator":
        r"""begin(pmt_vector_int32 self) -> std::vector< int >::iterator"""
        return _pmt_swig.pmt_vector_int32_begin(self)

    def end(self) -> "std::vector< int >::iterator":
        r"""end(pmt_vector_int32 self) -> std::vector< int >::iterator"""
        return _pmt_swig.pmt_vector_int32_end(self)

    def rbegin(self) -> "std::vector< int >::reverse_iterator":
        r"""rbegin(pmt_vector_int32 self) -> std::vector< int >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int32_rbegin(self)

    def rend(self) -> "std::vector< int >::reverse_iterator":
        r"""rend(pmt_vector_int32 self) -> std::vector< int >::reverse_iterator"""
        return _pmt_swig.pmt_vector_int32_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_int32 self)"""
        return _pmt_swig.pmt_vector_int32_clear(self)

    def get_allocator(self) -> "std::vector< int >::allocator_type":
        r"""get_allocator(pmt_vector_int32 self) -> std::vector< int >::allocator_type"""
        return _pmt_swig.pmt_vector_int32_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_int32 self)"""
        return _pmt_swig.pmt_vector_int32_pop_back(self)

    def erase(self, *args) -> "std::vector< int >::iterator":
        r"""
        erase(pmt_vector_int32 self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(pmt_vector_int32 self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _pmt_swig.pmt_vector_int32_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_int32 self) -> pmt_vector_int32
        __init__(pmt_vector_int32 self, pmt_vector_int32 other) -> pmt_vector_int32
        __init__(pmt_vector_int32 self, std::vector< int >::size_type size) -> pmt_vector_int32
        __init__(pmt_vector_int32 self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> pmt_vector_int32
        """
        _pmt_swig.pmt_vector_int32_swiginit(self, _pmt_swig.new_pmt_vector_int32(*args))

    def push_back(self, x: "std::vector< int >::value_type const &") -> "void":
        r"""push_back(pmt_vector_int32 self, std::vector< int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int32_push_back(self, x)

    def front(self) -> "std::vector< int >::value_type const &":
        r"""front(pmt_vector_int32 self) -> std::vector< int >::value_type const &"""
        return _pmt_swig.pmt_vector_int32_front(self)

    def back(self) -> "std::vector< int >::value_type const &":
        r"""back(pmt_vector_int32 self) -> std::vector< int >::value_type const &"""
        return _pmt_swig.pmt_vector_int32_back(self)

    def assign(self, n: "std::vector< int >::size_type", x: "std::vector< int >::value_type const &") -> "void":
        r"""assign(pmt_vector_int32 self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_int32_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_int32 self, std::vector< int >::size_type new_size)
        resize(pmt_vector_int32 self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int32_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_int32 self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(pmt_vector_int32 self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_int32_insert(self, *args)

    def reserve(self, n: "std::vector< int >::size_type") -> "void":
        r"""reserve(pmt_vector_int32 self, std::vector< int >::size_type n)"""
        return _pmt_swig.pmt_vector_int32_reserve(self, n)

    def capacity(self) -> "std::vector< int >::size_type":
        r"""capacity(pmt_vector_int32 self) -> std::vector< int >::size_type"""
        return _pmt_swig.pmt_vector_int32_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_int32

# Register pmt_vector_int32 in _pmt_swig:
_pmt_swig.pmt_vector_int32_swigregister(pmt_vector_int32)

class pmt_vector_uint32(object):
    r"""Proxy of C++ std::vector< uint32_t > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_uint32 self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_uint32_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_uint32 self) -> bool"""
        return _pmt_swig.pmt_vector_uint32___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_uint32 self) -> bool"""
        return _pmt_swig.pmt_vector_uint32___bool__(self)

    def __len__(self) -> "std::vector< unsigned int >::size_type":
        r"""__len__(pmt_vector_uint32 self) -> std::vector< unsigned int >::size_type"""
        return _pmt_swig.pmt_vector_uint32___len__(self)

    def __getslice__(self, i: "std::vector< unsigned int >::difference_type", j: "std::vector< unsigned int >::difference_type") -> "std::vector< unsigned int,std::allocator< unsigned int > > *":
        r"""__getslice__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) -> pmt_vector_uint32"""
        return _pmt_swig.pmt_vector_uint32___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)
        __setslice__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j, pmt_vector_uint32 v)
        """
        return _pmt_swig.pmt_vector_uint32___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< unsigned int >::difference_type", j: "std::vector< unsigned int >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)"""
        return _pmt_swig.pmt_vector_uint32___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i)
        __delitem__(pmt_vector_uint32 self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_uint32___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< unsigned int >::value_type const &":
        r"""
        __getitem__(pmt_vector_uint32 self, PySliceObject * slice) -> pmt_vector_uint32
        __getitem__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i) -> std::vector< unsigned int >::value_type const &
        """
        return _pmt_swig.pmt_vector_uint32___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_uint32 self, PySliceObject * slice, pmt_vector_uint32 v)
        __setitem__(pmt_vector_uint32 self, PySliceObject * slice)
        __setitem__(pmt_vector_uint32 self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint32___setitem__(self, *args)

    def pop(self) -> "std::vector< unsigned int >::value_type":
        r"""pop(pmt_vector_uint32 self) -> std::vector< unsigned int >::value_type"""
        return _pmt_swig.pmt_vector_uint32_pop(self)

    def append(self, x: "std::vector< unsigned int >::value_type const &") -> "void":
        r"""append(pmt_vector_uint32 self, std::vector< unsigned int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint32_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_uint32 self) -> bool"""
        return _pmt_swig.pmt_vector_uint32_empty(self)

    def size(self) -> "std::vector< unsigned int >::size_type":
        r"""size(pmt_vector_uint32 self) -> std::vector< unsigned int >::size_type"""
        return _pmt_swig.pmt_vector_uint32_size(self)

    def swap(self, v: "pmt_vector_uint32") -> "void":
        r"""swap(pmt_vector_uint32 self, pmt_vector_uint32 v)"""
        return _pmt_swig.pmt_vector_uint32_swap(self, v)

    def begin(self) -> "std::vector< unsigned int >::iterator":
        r"""begin(pmt_vector_uint32 self) -> std::vector< unsigned int >::iterator"""
        return _pmt_swig.pmt_vector_uint32_begin(self)

    def end(self) -> "std::vector< unsigned int >::iterator":
        r"""end(pmt_vector_uint32 self) -> std::vector< unsigned int >::iterator"""
        return _pmt_swig.pmt_vector_uint32_end(self)

    def rbegin(self) -> "std::vector< unsigned int >::reverse_iterator":
        r"""rbegin(pmt_vector_uint32 self) -> std::vector< unsigned int >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint32_rbegin(self)

    def rend(self) -> "std::vector< unsigned int >::reverse_iterator":
        r"""rend(pmt_vector_uint32 self) -> std::vector< unsigned int >::reverse_iterator"""
        return _pmt_swig.pmt_vector_uint32_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_uint32 self)"""
        return _pmt_swig.pmt_vector_uint32_clear(self)

    def get_allocator(self) -> "std::vector< unsigned int >::allocator_type":
        r"""get_allocator(pmt_vector_uint32 self) -> std::vector< unsigned int >::allocator_type"""
        return _pmt_swig.pmt_vector_uint32_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_uint32 self)"""
        return _pmt_swig.pmt_vector_uint32_pop_back(self)

    def erase(self, *args) -> "std::vector< unsigned int >::iterator":
        r"""
        erase(pmt_vector_uint32 self, std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator
        erase(pmt_vector_uint32 self, std::vector< unsigned int >::iterator first, std::vector< unsigned int >::iterator last) -> std::vector< unsigned int >::iterator
        """
        return _pmt_swig.pmt_vector_uint32_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_uint32 self) -> pmt_vector_uint32
        __init__(pmt_vector_uint32 self, pmt_vector_uint32 other) -> pmt_vector_uint32
        __init__(pmt_vector_uint32 self, std::vector< unsigned int >::size_type size) -> pmt_vector_uint32
        __init__(pmt_vector_uint32 self, std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> pmt_vector_uint32
        """
        _pmt_swig.pmt_vector_uint32_swiginit(self, _pmt_swig.new_pmt_vector_uint32(*args))

    def push_back(self, x: "std::vector< unsigned int >::value_type const &") -> "void":
        r"""push_back(pmt_vector_uint32 self, std::vector< unsigned int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint32_push_back(self, x)

    def front(self) -> "std::vector< unsigned int >::value_type const &":
        r"""front(pmt_vector_uint32 self) -> std::vector< unsigned int >::value_type const &"""
        return _pmt_swig.pmt_vector_uint32_front(self)

    def back(self) -> "std::vector< unsigned int >::value_type const &":
        r"""back(pmt_vector_uint32 self) -> std::vector< unsigned int >::value_type const &"""
        return _pmt_swig.pmt_vector_uint32_back(self)

    def assign(self, n: "std::vector< unsigned int >::size_type", x: "std::vector< unsigned int >::value_type const &") -> "void":
        r"""assign(pmt_vector_uint32 self, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)"""
        return _pmt_swig.pmt_vector_uint32_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_uint32 self, std::vector< unsigned int >::size_type new_size)
        resize(pmt_vector_uint32 self, std::vector< unsigned int >::size_type new_size, std::vector< unsigned int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint32_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_uint32 self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::value_type const & x) -> std::vector< unsigned int >::iterator
        insert(pmt_vector_uint32 self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_uint32_insert(self, *args)

    def reserve(self, n: "std::vector< unsigned int >::size_type") -> "void":
        r"""reserve(pmt_vector_uint32 self, std::vector< unsigned int >::size_type n)"""
        return _pmt_swig.pmt_vector_uint32_reserve(self, n)

    def capacity(self) -> "std::vector< unsigned int >::size_type":
        r"""capacity(pmt_vector_uint32 self) -> std::vector< unsigned int >::size_type"""
        return _pmt_swig.pmt_vector_uint32_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_uint32

# Register pmt_vector_uint32 in _pmt_swig:
_pmt_swig.pmt_vector_uint32_swigregister(pmt_vector_uint32)

class pmt_vector_float(object):
    r"""Proxy of C++ std::vector< float > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_float self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_float_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_float self) -> bool"""
        return _pmt_swig.pmt_vector_float___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_float self) -> bool"""
        return _pmt_swig.pmt_vector_float___bool__(self)

    def __len__(self) -> "std::vector< float >::size_type":
        r"""__len__(pmt_vector_float self) -> std::vector< float >::size_type"""
        return _pmt_swig.pmt_vector_float___len__(self)

    def __getslice__(self, i: "std::vector< float >::difference_type", j: "std::vector< float >::difference_type") -> "std::vector< float,std::allocator< float > > *":
        r"""__getslice__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::difference_type j) -> pmt_vector_float"""
        return _pmt_swig.pmt_vector_float___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)
        __setslice__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::difference_type j, pmt_vector_float v)
        """
        return _pmt_swig.pmt_vector_float___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< float >::difference_type", j: "std::vector< float >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)"""
        return _pmt_swig.pmt_vector_float___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_float self, std::vector< float >::difference_type i)
        __delitem__(pmt_vector_float self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_float___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< float >::value_type const &":
        r"""
        __getitem__(pmt_vector_float self, PySliceObject * slice) -> pmt_vector_float
        __getitem__(pmt_vector_float self, std::vector< float >::difference_type i) -> std::vector< float >::value_type const &
        """
        return _pmt_swig.pmt_vector_float___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_float self, PySliceObject * slice, pmt_vector_float v)
        __setitem__(pmt_vector_float self, PySliceObject * slice)
        __setitem__(pmt_vector_float self, std::vector< float >::difference_type i, std::vector< float >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_float___setitem__(self, *args)

    def pop(self) -> "std::vector< float >::value_type":
        r"""pop(pmt_vector_float self) -> std::vector< float >::value_type"""
        return _pmt_swig.pmt_vector_float_pop(self)

    def append(self, x: "std::vector< float >::value_type const &") -> "void":
        r"""append(pmt_vector_float self, std::vector< float >::value_type const & x)"""
        return _pmt_swig.pmt_vector_float_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_float self) -> bool"""
        return _pmt_swig.pmt_vector_float_empty(self)

    def size(self) -> "std::vector< float >::size_type":
        r"""size(pmt_vector_float self) -> std::vector< float >::size_type"""
        return _pmt_swig.pmt_vector_float_size(self)

    def swap(self, v: "pmt_vector_float") -> "void":
        r"""swap(pmt_vector_float self, pmt_vector_float v)"""
        return _pmt_swig.pmt_vector_float_swap(self, v)

    def begin(self) -> "std::vector< float >::iterator":
        r"""begin(pmt_vector_float self) -> std::vector< float >::iterator"""
        return _pmt_swig.pmt_vector_float_begin(self)

    def end(self) -> "std::vector< float >::iterator":
        r"""end(pmt_vector_float self) -> std::vector< float >::iterator"""
        return _pmt_swig.pmt_vector_float_end(self)

    def rbegin(self) -> "std::vector< float >::reverse_iterator":
        r"""rbegin(pmt_vector_float self) -> std::vector< float >::reverse_iterator"""
        return _pmt_swig.pmt_vector_float_rbegin(self)

    def rend(self) -> "std::vector< float >::reverse_iterator":
        r"""rend(pmt_vector_float self) -> std::vector< float >::reverse_iterator"""
        return _pmt_swig.pmt_vector_float_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_float self)"""
        return _pmt_swig.pmt_vector_float_clear(self)

    def get_allocator(self) -> "std::vector< float >::allocator_type":
        r"""get_allocator(pmt_vector_float self) -> std::vector< float >::allocator_type"""
        return _pmt_swig.pmt_vector_float_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_float self)"""
        return _pmt_swig.pmt_vector_float_pop_back(self)

    def erase(self, *args) -> "std::vector< float >::iterator":
        r"""
        erase(pmt_vector_float self, std::vector< float >::iterator pos) -> std::vector< float >::iterator
        erase(pmt_vector_float self, std::vector< float >::iterator first, std::vector< float >::iterator last) -> std::vector< float >::iterator
        """
        return _pmt_swig.pmt_vector_float_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_float self) -> pmt_vector_float
        __init__(pmt_vector_float self, pmt_vector_float other) -> pmt_vector_float
        __init__(pmt_vector_float self, std::vector< float >::size_type size) -> pmt_vector_float
        __init__(pmt_vector_float self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> pmt_vector_float
        """
        _pmt_swig.pmt_vector_float_swiginit(self, _pmt_swig.new_pmt_vector_float(*args))

    def push_back(self, x: "std::vector< float >::value_type const &") -> "void":
        r"""push_back(pmt_vector_float self, std::vector< float >::value_type const & x)"""
        return _pmt_swig.pmt_vector_float_push_back(self, x)

    def front(self) -> "std::vector< float >::value_type const &":
        r"""front(pmt_vector_float self) -> std::vector< float >::value_type const &"""
        return _pmt_swig.pmt_vector_float_front(self)

    def back(self) -> "std::vector< float >::value_type const &":
        r"""back(pmt_vector_float self) -> std::vector< float >::value_type const &"""
        return _pmt_swig.pmt_vector_float_back(self)

    def assign(self, n: "std::vector< float >::size_type", x: "std::vector< float >::value_type const &") -> "void":
        r"""assign(pmt_vector_float self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _pmt_swig.pmt_vector_float_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_float self, std::vector< float >::size_type new_size)
        resize(pmt_vector_float self, std::vector< float >::size_type new_size, std::vector< float >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_float_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_float self, std::vector< float >::iterator pos, std::vector< float >::value_type const & x) -> std::vector< float >::iterator
        insert(pmt_vector_float self, std::vector< float >::iterator pos, std::vector< float >::size_type n, std::vector< float >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_float_insert(self, *args)

    def reserve(self, n: "std::vector< float >::size_type") -> "void":
        r"""reserve(pmt_vector_float self, std::vector< float >::size_type n)"""
        return _pmt_swig.pmt_vector_float_reserve(self, n)

    def capacity(self) -> "std::vector< float >::size_type":
        r"""capacity(pmt_vector_float self) -> std::vector< float >::size_type"""
        return _pmt_swig.pmt_vector_float_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_float

# Register pmt_vector_float in _pmt_swig:
_pmt_swig.pmt_vector_float_swigregister(pmt_vector_float)

class pmt_vector_double(object):
    r"""Proxy of C++ std::vector< double > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_double self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_double_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_double self) -> bool"""
        return _pmt_swig.pmt_vector_double___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_double self) -> bool"""
        return _pmt_swig.pmt_vector_double___bool__(self)

    def __len__(self) -> "std::vector< double >::size_type":
        r"""__len__(pmt_vector_double self) -> std::vector< double >::size_type"""
        return _pmt_swig.pmt_vector_double___len__(self)

    def __getslice__(self, i: "std::vector< double >::difference_type", j: "std::vector< double >::difference_type") -> "std::vector< double,std::allocator< double > > *":
        r"""__getslice__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> pmt_vector_double"""
        return _pmt_swig.pmt_vector_double___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, pmt_vector_double v)
        """
        return _pmt_swig.pmt_vector_double___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< double >::difference_type", j: "std::vector< double >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _pmt_swig.pmt_vector_double___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_double self, std::vector< double >::difference_type i)
        __delitem__(pmt_vector_double self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_double___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< double >::value_type const &":
        r"""
        __getitem__(pmt_vector_double self, PySliceObject * slice) -> pmt_vector_double
        __getitem__(pmt_vector_double self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _pmt_swig.pmt_vector_double___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_double self, PySliceObject * slice, pmt_vector_double v)
        __setitem__(pmt_vector_double self, PySliceObject * slice)
        __setitem__(pmt_vector_double self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_double___setitem__(self, *args)

    def pop(self) -> "std::vector< double >::value_type":
        r"""pop(pmt_vector_double self) -> std::vector< double >::value_type"""
        return _pmt_swig.pmt_vector_double_pop(self)

    def append(self, x: "std::vector< double >::value_type const &") -> "void":
        r"""append(pmt_vector_double self, std::vector< double >::value_type const & x)"""
        return _pmt_swig.pmt_vector_double_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_double self) -> bool"""
        return _pmt_swig.pmt_vector_double_empty(self)

    def size(self) -> "std::vector< double >::size_type":
        r"""size(pmt_vector_double self) -> std::vector< double >::size_type"""
        return _pmt_swig.pmt_vector_double_size(self)

    def swap(self, v: "pmt_vector_double") -> "void":
        r"""swap(pmt_vector_double self, pmt_vector_double v)"""
        return _pmt_swig.pmt_vector_double_swap(self, v)

    def begin(self) -> "std::vector< double >::iterator":
        r"""begin(pmt_vector_double self) -> std::vector< double >::iterator"""
        return _pmt_swig.pmt_vector_double_begin(self)

    def end(self) -> "std::vector< double >::iterator":
        r"""end(pmt_vector_double self) -> std::vector< double >::iterator"""
        return _pmt_swig.pmt_vector_double_end(self)

    def rbegin(self) -> "std::vector< double >::reverse_iterator":
        r"""rbegin(pmt_vector_double self) -> std::vector< double >::reverse_iterator"""
        return _pmt_swig.pmt_vector_double_rbegin(self)

    def rend(self) -> "std::vector< double >::reverse_iterator":
        r"""rend(pmt_vector_double self) -> std::vector< double >::reverse_iterator"""
        return _pmt_swig.pmt_vector_double_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_double self)"""
        return _pmt_swig.pmt_vector_double_clear(self)

    def get_allocator(self) -> "std::vector< double >::allocator_type":
        r"""get_allocator(pmt_vector_double self) -> std::vector< double >::allocator_type"""
        return _pmt_swig.pmt_vector_double_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_double self)"""
        return _pmt_swig.pmt_vector_double_pop_back(self)

    def erase(self, *args) -> "std::vector< double >::iterator":
        r"""
        erase(pmt_vector_double self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(pmt_vector_double self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _pmt_swig.pmt_vector_double_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_double self) -> pmt_vector_double
        __init__(pmt_vector_double self, pmt_vector_double other) -> pmt_vector_double
        __init__(pmt_vector_double self, std::vector< double >::size_type size) -> pmt_vector_double
        __init__(pmt_vector_double self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> pmt_vector_double
        """
        _pmt_swig.pmt_vector_double_swiginit(self, _pmt_swig.new_pmt_vector_double(*args))

    def push_back(self, x: "std::vector< double >::value_type const &") -> "void":
        r"""push_back(pmt_vector_double self, std::vector< double >::value_type const & x)"""
        return _pmt_swig.pmt_vector_double_push_back(self, x)

    def front(self) -> "std::vector< double >::value_type const &":
        r"""front(pmt_vector_double self) -> std::vector< double >::value_type const &"""
        return _pmt_swig.pmt_vector_double_front(self)

    def back(self) -> "std::vector< double >::value_type const &":
        r"""back(pmt_vector_double self) -> std::vector< double >::value_type const &"""
        return _pmt_swig.pmt_vector_double_back(self)

    def assign(self, n: "std::vector< double >::size_type", x: "std::vector< double >::value_type const &") -> "void":
        r"""assign(pmt_vector_double self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _pmt_swig.pmt_vector_double_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_double self, std::vector< double >::size_type new_size)
        resize(pmt_vector_double self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_double_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_double self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(pmt_vector_double self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_double_insert(self, *args)

    def reserve(self, n: "std::vector< double >::size_type") -> "void":
        r"""reserve(pmt_vector_double self, std::vector< double >::size_type n)"""
        return _pmt_swig.pmt_vector_double_reserve(self, n)

    def capacity(self) -> "std::vector< double >::size_type":
        r"""capacity(pmt_vector_double self) -> std::vector< double >::size_type"""
        return _pmt_swig.pmt_vector_double_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_double

# Register pmt_vector_double in _pmt_swig:
_pmt_swig.pmt_vector_double_swigregister(pmt_vector_double)

class pmt_vector_cfloat(object):
    r"""Proxy of C++ std::vector< std::complex< float > > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_cfloat self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_cfloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_cfloat self) -> bool"""
        return _pmt_swig.pmt_vector_cfloat___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_cfloat self) -> bool"""
        return _pmt_swig.pmt_vector_cfloat___bool__(self)

    def __len__(self) -> "std::vector< std::complex< float > >::size_type":
        r"""__len__(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::size_type"""
        return _pmt_swig.pmt_vector_cfloat___len__(self)

    def __getslice__(self, i: "std::vector< std::complex< float > >::difference_type", j: "std::vector< std::complex< float > >::difference_type") -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > > *":
        r"""__getslice__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::difference_type j) -> pmt_vector_cfloat"""
        return _pmt_swig.pmt_vector_cfloat___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::difference_type j)
        __setslice__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::difference_type j, pmt_vector_cfloat v)
        """
        return _pmt_swig.pmt_vector_cfloat___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::complex< float > >::difference_type", j: "std::vector< std::complex< float > >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::difference_type j)"""
        return _pmt_swig.pmt_vector_cfloat___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i)
        __delitem__(pmt_vector_cfloat self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_cfloat___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::complex< float > >::value_type const &":
        r"""
        __getitem__(pmt_vector_cfloat self, PySliceObject * slice) -> pmt_vector_cfloat
        __getitem__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i) -> std::vector< std::complex< float > >::value_type const &
        """
        return _pmt_swig.pmt_vector_cfloat___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_cfloat self, PySliceObject * slice, pmt_vector_cfloat v)
        __setitem__(pmt_vector_cfloat self, PySliceObject * slice)
        __setitem__(pmt_vector_cfloat self, std::vector< std::complex< float > >::difference_type i, std::vector< std::complex< float > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cfloat___setitem__(self, *args)

    def pop(self) -> "std::vector< std::complex< float > >::value_type":
        r"""pop(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::value_type"""
        return _pmt_swig.pmt_vector_cfloat_pop(self)

    def append(self, x: "std::vector< std::complex< float > >::value_type const &") -> "void":
        r"""append(pmt_vector_cfloat self, std::vector< std::complex< float > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cfloat_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_cfloat self) -> bool"""
        return _pmt_swig.pmt_vector_cfloat_empty(self)

    def size(self) -> "std::vector< std::complex< float > >::size_type":
        r"""size(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::size_type"""
        return _pmt_swig.pmt_vector_cfloat_size(self)

    def swap(self, v: "pmt_vector_cfloat") -> "void":
        r"""swap(pmt_vector_cfloat self, pmt_vector_cfloat v)"""
        return _pmt_swig.pmt_vector_cfloat_swap(self, v)

    def begin(self) -> "std::vector< std::complex< float > >::iterator":
        r"""begin(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::iterator"""
        return _pmt_swig.pmt_vector_cfloat_begin(self)

    def end(self) -> "std::vector< std::complex< float > >::iterator":
        r"""end(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::iterator"""
        return _pmt_swig.pmt_vector_cfloat_end(self)

    def rbegin(self) -> "std::vector< std::complex< float > >::reverse_iterator":
        r"""rbegin(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::reverse_iterator"""
        return _pmt_swig.pmt_vector_cfloat_rbegin(self)

    def rend(self) -> "std::vector< std::complex< float > >::reverse_iterator":
        r"""rend(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::reverse_iterator"""
        return _pmt_swig.pmt_vector_cfloat_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_cfloat self)"""
        return _pmt_swig.pmt_vector_cfloat_clear(self)

    def get_allocator(self) -> "std::vector< std::complex< float > >::allocator_type":
        r"""get_allocator(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::allocator_type"""
        return _pmt_swig.pmt_vector_cfloat_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_cfloat self)"""
        return _pmt_swig.pmt_vector_cfloat_pop_back(self)

    def erase(self, *args) -> "std::vector< std::complex< float > >::iterator":
        r"""
        erase(pmt_vector_cfloat self, std::vector< std::complex< float > >::iterator pos) -> std::vector< std::complex< float > >::iterator
        erase(pmt_vector_cfloat self, std::vector< std::complex< float > >::iterator first, std::vector< std::complex< float > >::iterator last) -> std::vector< std::complex< float > >::iterator
        """
        return _pmt_swig.pmt_vector_cfloat_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_cfloat self) -> pmt_vector_cfloat
        __init__(pmt_vector_cfloat self, pmt_vector_cfloat other) -> pmt_vector_cfloat
        __init__(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type size) -> pmt_vector_cfloat
        __init__(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type size, std::vector< std::complex< float > >::value_type const & value) -> pmt_vector_cfloat
        """
        _pmt_swig.pmt_vector_cfloat_swiginit(self, _pmt_swig.new_pmt_vector_cfloat(*args))

    def push_back(self, x: "std::vector< std::complex< float > >::value_type const &") -> "void":
        r"""push_back(pmt_vector_cfloat self, std::vector< std::complex< float > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cfloat_push_back(self, x)

    def front(self) -> "std::vector< std::complex< float > >::value_type const &":
        r"""front(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::value_type const &"""
        return _pmt_swig.pmt_vector_cfloat_front(self)

    def back(self) -> "std::vector< std::complex< float > >::value_type const &":
        r"""back(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::value_type const &"""
        return _pmt_swig.pmt_vector_cfloat_back(self)

    def assign(self, n: "std::vector< std::complex< float > >::size_type", x: "std::vector< std::complex< float > >::value_type const &") -> "void":
        r"""assign(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type n, std::vector< std::complex< float > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cfloat_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type new_size)
        resize(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type new_size, std::vector< std::complex< float > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cfloat_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_cfloat self, std::vector< std::complex< float > >::iterator pos, std::vector< std::complex< float > >::value_type const & x) -> std::vector< std::complex< float > >::iterator
        insert(pmt_vector_cfloat self, std::vector< std::complex< float > >::iterator pos, std::vector< std::complex< float > >::size_type n, std::vector< std::complex< float > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cfloat_insert(self, *args)

    def reserve(self, n: "std::vector< std::complex< float > >::size_type") -> "void":
        r"""reserve(pmt_vector_cfloat self, std::vector< std::complex< float > >::size_type n)"""
        return _pmt_swig.pmt_vector_cfloat_reserve(self, n)

    def capacity(self) -> "std::vector< std::complex< float > >::size_type":
        r"""capacity(pmt_vector_cfloat self) -> std::vector< std::complex< float > >::size_type"""
        return _pmt_swig.pmt_vector_cfloat_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_cfloat

# Register pmt_vector_cfloat in _pmt_swig:
_pmt_swig.pmt_vector_cfloat_swigregister(pmt_vector_cfloat)

class pmt_vector_cdouble(object):
    r"""Proxy of C++ std::vector< std::complex< double > > 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) -> "swig::SwigPyIterator *":
        r"""iterator(pmt_vector_cdouble self) -> SwigPyIterator"""
        return _pmt_swig.pmt_vector_cdouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(pmt_vector_cdouble self) -> bool"""
        return _pmt_swig.pmt_vector_cdouble___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(pmt_vector_cdouble self) -> bool"""
        return _pmt_swig.pmt_vector_cdouble___bool__(self)

    def __len__(self) -> "std::vector< std::complex< double > >::size_type":
        r"""__len__(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::size_type"""
        return _pmt_swig.pmt_vector_cdouble___len__(self)

    def __getslice__(self, i: "std::vector< std::complex< double > >::difference_type", j: "std::vector< std::complex< double > >::difference_type") -> "std::vector< std::complex< double >,std::allocator< std::complex< double > > > *":
        r"""__getslice__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> pmt_vector_cdouble"""
        return _pmt_swig.pmt_vector_cdouble___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
        __setslice__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, pmt_vector_cdouble v)
        """
        return _pmt_swig.pmt_vector_cdouble___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::complex< double > >::difference_type", j: "std::vector< std::complex< double > >::difference_type") -> "void":
        r"""__delslice__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"""
        return _pmt_swig.pmt_vector_cdouble___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i)
        __delitem__(pmt_vector_cdouble self, PySliceObject * slice)
        """
        return _pmt_swig.pmt_vector_cdouble___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::complex< double > >::value_type const &":
        r"""
        __getitem__(pmt_vector_cdouble self, PySliceObject * slice) -> pmt_vector_cdouble
        __getitem__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
        """
        return _pmt_swig.pmt_vector_cdouble___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(pmt_vector_cdouble self, PySliceObject * slice, pmt_vector_cdouble v)
        __setitem__(pmt_vector_cdouble self, PySliceObject * slice)
        __setitem__(pmt_vector_cdouble self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cdouble___setitem__(self, *args)

    def pop(self) -> "std::vector< std::complex< double > >::value_type":
        r"""pop(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::value_type"""
        return _pmt_swig.pmt_vector_cdouble_pop(self)

    def append(self, x: "std::vector< std::complex< double > >::value_type const &") -> "void":
        r"""append(pmt_vector_cdouble self, std::vector< std::complex< double > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cdouble_append(self, x)

    def empty(self) -> "bool":
        r"""empty(pmt_vector_cdouble self) -> bool"""
        return _pmt_swig.pmt_vector_cdouble_empty(self)

    def size(self) -> "std::vector< std::complex< double > >::size_type":
        r"""size(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::size_type"""
        return _pmt_swig.pmt_vector_cdouble_size(self)

    def swap(self, v: "pmt_vector_cdouble") -> "void":
        r"""swap(pmt_vector_cdouble self, pmt_vector_cdouble v)"""
        return _pmt_swig.pmt_vector_cdouble_swap(self, v)

    def begin(self) -> "std::vector< std::complex< double > >::iterator":
        r"""begin(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::iterator"""
        return _pmt_swig.pmt_vector_cdouble_begin(self)

    def end(self) -> "std::vector< std::complex< double > >::iterator":
        r"""end(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::iterator"""
        return _pmt_swig.pmt_vector_cdouble_end(self)

    def rbegin(self) -> "std::vector< std::complex< double > >::reverse_iterator":
        r"""rbegin(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _pmt_swig.pmt_vector_cdouble_rbegin(self)

    def rend(self) -> "std::vector< std::complex< double > >::reverse_iterator":
        r"""rend(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _pmt_swig.pmt_vector_cdouble_rend(self)

    def clear(self) -> "void":
        r"""clear(pmt_vector_cdouble self)"""
        return _pmt_swig.pmt_vector_cdouble_clear(self)

    def get_allocator(self) -> "std::vector< std::complex< double > >::allocator_type":
        r"""get_allocator(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::allocator_type"""
        return _pmt_swig.pmt_vector_cdouble_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(pmt_vector_cdouble self)"""
        return _pmt_swig.pmt_vector_cdouble_pop_back(self)

    def erase(self, *args) -> "std::vector< std::complex< double > >::iterator":
        r"""
        erase(pmt_vector_cdouble self, std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator
        erase(pmt_vector_cdouble self, std::vector< std::complex< double > >::iterator first, std::vector< std::complex< double > >::iterator last) -> std::vector< std::complex< double > >::iterator
        """
        return _pmt_swig.pmt_vector_cdouble_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(pmt_vector_cdouble self) -> pmt_vector_cdouble
        __init__(pmt_vector_cdouble self, pmt_vector_cdouble other) -> pmt_vector_cdouble
        __init__(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type size) -> pmt_vector_cdouble
        __init__(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type size, std::vector< std::complex< double > >::value_type const & value) -> pmt_vector_cdouble
        """
        _pmt_swig.pmt_vector_cdouble_swiginit(self, _pmt_swig.new_pmt_vector_cdouble(*args))

    def push_back(self, x: "std::vector< std::complex< double > >::value_type const &") -> "void":
        r"""push_back(pmt_vector_cdouble self, std::vector< std::complex< double > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cdouble_push_back(self, x)

    def front(self) -> "std::vector< std::complex< double > >::value_type const &":
        r"""front(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::value_type const &"""
        return _pmt_swig.pmt_vector_cdouble_front(self)

    def back(self) -> "std::vector< std::complex< double > >::value_type const &":
        r"""back(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::value_type const &"""
        return _pmt_swig.pmt_vector_cdouble_back(self)

    def assign(self, n: "std::vector< std::complex< double > >::size_type", x: "std::vector< std::complex< double > >::value_type const &") -> "void":
        r"""assign(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)"""
        return _pmt_swig.pmt_vector_cdouble_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type new_size)
        resize(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type new_size, std::vector< std::complex< double > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cdouble_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(pmt_vector_cdouble self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::value_type const & x) -> std::vector< std::complex< double > >::iterator
        insert(pmt_vector_cdouble self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)
        """
        return _pmt_swig.pmt_vector_cdouble_insert(self, *args)

    def reserve(self, n: "std::vector< std::complex< double > >::size_type") -> "void":
        r"""reserve(pmt_vector_cdouble self, std::vector< std::complex< double > >::size_type n)"""
        return _pmt_swig.pmt_vector_cdouble_reserve(self, n)

    def capacity(self) -> "std::vector< std::complex< double > >::size_type":
        r"""capacity(pmt_vector_cdouble self) -> std::vector< std::complex< double > >::size_type"""
        return _pmt_swig.pmt_vector_cdouble_capacity(self)
    __swig_destroy__ = _pmt_swig.delete_pmt_vector_cdouble

# Register pmt_vector_cdouble in _pmt_swig:
_pmt_swig.pmt_vector_cdouble_swigregister(pmt_vector_cdouble)

class swig_pmt_ptr(object):
    r"""Proxy of C++ boost::shared_ptr< pmt::pmt_base > 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, *args):
        r"""
        __init__(swig_pmt_ptr self) -> swig_pmt_ptr
        __init__(swig_pmt_ptr self, pmt::pmt_base * p) -> swig_pmt_ptr
        """
        _pmt_swig.swig_pmt_ptr_swiginit(self, _pmt_swig.new_swig_pmt_ptr(*args))

    def __deref__(self) -> "pmt::pmt_base *":
        r"""__deref__(swig_pmt_ptr self) -> pmt::pmt_base *"""
        return _pmt_swig.swig_pmt_ptr___deref__(self)
    __swig_destroy__ = _pmt_swig.delete_swig_pmt_ptr

# Register swig_pmt_ptr in _pmt_swig:
_pmt_swig.swig_pmt_ptr_swigregister(swig_pmt_ptr)


swig_pmt_ptr.__repr__ = lambda self: write_string(self)


def get_PMT_NIL() -> "pmt::pmt_t":
    r"""get_PMT_NIL() -> swig_pmt_ptr"""
    return _pmt_swig.get_PMT_NIL()

def get_PMT_T() -> "pmt::pmt_t":
    r"""get_PMT_T() -> swig_pmt_ptr"""
    return _pmt_swig.get_PMT_T()

def get_PMT_F() -> "pmt::pmt_t":
    r"""get_PMT_F() -> swig_pmt_ptr"""
    return _pmt_swig.get_PMT_F()

def get_PMT_EOF() -> "pmt::pmt_t":
    r"""get_PMT_EOF() -> swig_pmt_ptr"""
    return _pmt_swig.get_PMT_EOF()

def is_bool(obj: "swig_pmt_ptr") -> "bool":
    r"""is_bool(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_bool(obj)

def is_true(obj: "swig_pmt_ptr") -> "bool":
    r"""is_true(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_true(obj)

def is_false(obj: "swig_pmt_ptr") -> "bool":
    r"""is_false(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_false(obj)

def from_bool(val: "bool") -> "pmt::pmt_t":
    r"""from_bool(bool val) -> swig_pmt_ptr"""
    return _pmt_swig.from_bool(val)

def to_bool(val: "swig_pmt_ptr") -> "bool":
    r"""to_bool(swig_pmt_ptr val) -> bool"""
    return _pmt_swig.to_bool(val)

def is_symbol(obj: "swig_pmt_ptr") -> "bool":
    r"""is_symbol(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_symbol(obj)

def string_to_symbol(s: "std::string const &") -> "pmt::pmt_t":
    r"""string_to_symbol(std::string const & s) -> swig_pmt_ptr"""
    return _pmt_swig.string_to_symbol(s)

def intern(s: "std::string const &") -> "pmt::pmt_t":
    r"""intern(std::string const & s) -> swig_pmt_ptr"""
    return _pmt_swig.intern(s)

def symbol_to_string(sym: "swig_pmt_ptr") -> "std::string const":
    r"""symbol_to_string(swig_pmt_ptr sym) -> std::string const"""
    return _pmt_swig.symbol_to_string(sym)

def is_number(obj: "swig_pmt_ptr") -> "bool":
    r"""is_number(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_number(obj)

def is_integer(x: "swig_pmt_ptr") -> "bool":
    r"""is_integer(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_integer(x)

def from_long(x: "long") -> "pmt::pmt_t":
    r"""from_long(long x) -> swig_pmt_ptr"""
    return _pmt_swig.from_long(x)

def to_long(x: "swig_pmt_ptr") -> "long":
    r"""to_long(swig_pmt_ptr x) -> long"""
    return _pmt_swig.to_long(x)

def is_uint64(x: "swig_pmt_ptr") -> "bool":
    r"""is_uint64(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_uint64(x)

def from_uint64(x: "uint64_t") -> "pmt::pmt_t":
    r"""from_uint64(uint64_t x) -> swig_pmt_ptr"""
    return _pmt_swig.from_uint64(x)

def to_uint64(x: "swig_pmt_ptr") -> "uint64_t":
    r"""to_uint64(swig_pmt_ptr x) -> uint64_t"""
    return _pmt_swig.to_uint64(x)

def is_real(obj: "swig_pmt_ptr") -> "bool":
    r"""is_real(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_real(obj)

def from_double(x: "double") -> "pmt::pmt_t":
    r"""from_double(double x) -> swig_pmt_ptr"""
    return _pmt_swig.from_double(x)

def to_double(x: "swig_pmt_ptr") -> "double":
    r"""to_double(swig_pmt_ptr x) -> double"""
    return _pmt_swig.to_double(x)

def from_float(x: "double") -> "pmt::pmt_t":
    r"""from_float(double x) -> swig_pmt_ptr"""
    return _pmt_swig.from_float(x)

def to_float(x: "swig_pmt_ptr") -> "double":
    r"""to_float(swig_pmt_ptr x) -> double"""
    return _pmt_swig.to_float(x)

def is_complex(obj: "swig_pmt_ptr") -> "bool":
    r"""is_complex(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_complex(obj)

def make_rectangular(re: "double", im: "double") -> "pmt::pmt_t":
    r"""make_rectangular(double re, double im) -> swig_pmt_ptr"""
    return _pmt_swig.make_rectangular(re, im)

def from_complex(z: "std::complex< double > const &") -> "pmt::pmt_t":
    r"""from_complex(std::complex< double > const & z) -> swig_pmt_ptr"""
    return _pmt_swig.from_complex(z)

def to_complex(z: "swig_pmt_ptr") -> "std::complex< double >":
    r"""to_complex(swig_pmt_ptr z) -> std::complex< double >"""
    return _pmt_swig.to_complex(z)

def is_null(x: "swig_pmt_ptr") -> "bool":
    r"""is_null(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_null(x)

def is_pair(obj: "swig_pmt_ptr") -> "bool":
    r"""is_pair(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_pair(obj)

def cons(x: "swig_pmt_ptr", y: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""cons(swig_pmt_ptr x, swig_pmt_ptr y) -> swig_pmt_ptr"""
    return _pmt_swig.cons(x, y)

def car(pair: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""car(swig_pmt_ptr pair) -> swig_pmt_ptr"""
    return _pmt_swig.car(pair)

def cdr(pair: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""cdr(swig_pmt_ptr pair) -> swig_pmt_ptr"""
    return _pmt_swig.cdr(pair)

def set_car(pair: "swig_pmt_ptr", value: "swig_pmt_ptr") -> "void":
    r"""set_car(swig_pmt_ptr pair, swig_pmt_ptr value)"""
    return _pmt_swig.set_car(pair, value)

def set_cdr(pair: "swig_pmt_ptr", value: "swig_pmt_ptr") -> "void":
    r"""set_cdr(swig_pmt_ptr pair, swig_pmt_ptr value)"""
    return _pmt_swig.set_cdr(pair, value)

def caar(pair: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""caar(swig_pmt_ptr pair) -> swig_pmt_ptr"""
    return _pmt_swig.caar(pair)

def cadr(pair: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""cadr(swig_pmt_ptr pair) -> swig_pmt_ptr"""
    return _pmt_swig.cadr(pair)

def cdar(pair: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""cdar(swig_pmt_ptr pair) -> swig_pmt_ptr"""
    return _pmt_swig.cdar(pair)

def cddr(pair: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""cddr(swig_pmt_ptr pair) -> swig_pmt_ptr"""
    return _pmt_swig.cddr(pair)

def caddr(pair: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""caddr(swig_pmt_ptr pair) -> swig_pmt_ptr"""
    return _pmt_swig.caddr(pair)

def cadddr(pair: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""cadddr(swig_pmt_ptr pair) -> swig_pmt_ptr"""
    return _pmt_swig.cadddr(pair)

def is_tuple(x: "swig_pmt_ptr") -> "bool":
    r"""is_tuple(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_tuple(x)

def make_tuple(*args) -> "pmt::pmt_t":
    r"""
    make_tuple() -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1, swig_pmt_ptr e2) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1, swig_pmt_ptr e2, swig_pmt_ptr e3) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1, swig_pmt_ptr e2, swig_pmt_ptr e3, swig_pmt_ptr e4) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1, swig_pmt_ptr e2, swig_pmt_ptr e3, swig_pmt_ptr e4, swig_pmt_ptr e5) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1, swig_pmt_ptr e2, swig_pmt_ptr e3, swig_pmt_ptr e4, swig_pmt_ptr e5, swig_pmt_ptr e6) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1, swig_pmt_ptr e2, swig_pmt_ptr e3, swig_pmt_ptr e4, swig_pmt_ptr e5, swig_pmt_ptr e6, swig_pmt_ptr e7) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1, swig_pmt_ptr e2, swig_pmt_ptr e3, swig_pmt_ptr e4, swig_pmt_ptr e5, swig_pmt_ptr e6, swig_pmt_ptr e7, swig_pmt_ptr e8) -> swig_pmt_ptr
    make_tuple(swig_pmt_ptr e0, swig_pmt_ptr e1, swig_pmt_ptr e2, swig_pmt_ptr e3, swig_pmt_ptr e4, swig_pmt_ptr e5, swig_pmt_ptr e6, swig_pmt_ptr e7, swig_pmt_ptr e8, swig_pmt_ptr e9) -> swig_pmt_ptr
    """
    return _pmt_swig.make_tuple(*args)

def to_tuple(x: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""to_tuple(swig_pmt_ptr x) -> swig_pmt_ptr"""
    return _pmt_swig.to_tuple(x)

def tuple_ref(tuple: "swig_pmt_ptr", k: "size_t") -> "pmt::pmt_t":
    r"""tuple_ref(swig_pmt_ptr tuple, size_t k) -> swig_pmt_ptr"""
    return _pmt_swig.tuple_ref(tuple, k)

def is_vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_vector(x)

def make_vector(k: "size_t", fill: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""make_vector(size_t k, swig_pmt_ptr fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_vector(k, fill)

def vector_ref(vector: "swig_pmt_ptr", k: "size_t") -> "pmt::pmt_t":
    r"""vector_ref(swig_pmt_ptr vector, size_t k) -> swig_pmt_ptr"""
    return _pmt_swig.vector_ref(vector, k)

def vector_set(vector: "swig_pmt_ptr", k: "size_t", obj: "swig_pmt_ptr") -> "void":
    r"""vector_set(swig_pmt_ptr vector, size_t k, swig_pmt_ptr obj)"""
    return _pmt_swig.vector_set(vector, k, obj)

def vector_fill(vector: "swig_pmt_ptr", fill: "swig_pmt_ptr") -> "void":
    r"""vector_fill(swig_pmt_ptr vector, swig_pmt_ptr fill)"""
    return _pmt_swig.vector_fill(vector, fill)

def is_blob(x: "swig_pmt_ptr") -> "bool":
    r"""is_blob(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_blob(x)

def make_blob(buf: "void const *", len: "size_t") -> "pmt::pmt_t":
    r"""make_blob(void const * buf, size_t len) -> swig_pmt_ptr"""
    return _pmt_swig.make_blob(buf, len)

def blob_data(blob: "swig_pmt_ptr") -> "void const *":
    r"""blob_data(swig_pmt_ptr blob) -> void const *"""
    return _pmt_swig.blob_data(blob)

def blob_length(blob: "swig_pmt_ptr") -> "size_t":
    r"""blob_length(swig_pmt_ptr blob) -> size_t"""
    return _pmt_swig.blob_length(blob)

def is_uniform_vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_uniform_vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_uniform_vector(x)

def is_u8vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_u8vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_u8vector(x)

def is_s8vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_s8vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_s8vector(x)

def is_u16vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_u16vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_u16vector(x)

def is_s16vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_s16vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_s16vector(x)

def is_u32vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_u32vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_u32vector(x)

def is_s32vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_s32vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_s32vector(x)

def is_u64vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_u64vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_u64vector(x)

def is_s64vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_s64vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_s64vector(x)

def is_f32vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_f32vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_f32vector(x)

def is_f64vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_f64vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_f64vector(x)

def is_c32vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_c32vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_c32vector(x)

def is_c64vector(x: "swig_pmt_ptr") -> "bool":
    r"""is_c64vector(swig_pmt_ptr x) -> bool"""
    return _pmt_swig.is_c64vector(x)

def uniform_vector_itemsize(x: "swig_pmt_ptr") -> "size_t":
    r"""uniform_vector_itemsize(swig_pmt_ptr x) -> size_t"""
    return _pmt_swig.uniform_vector_itemsize(x)

def make_u8vector(k: "size_t", fill: "uint8_t") -> "pmt::pmt_t":
    r"""make_u8vector(size_t k, uint8_t fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_u8vector(k, fill)

def make_s8vector(k: "size_t", fill: "int8_t") -> "pmt::pmt_t":
    r"""make_s8vector(size_t k, int8_t fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_s8vector(k, fill)

def make_u16vector(k: "size_t", fill: "uint16_t") -> "pmt::pmt_t":
    r"""make_u16vector(size_t k, uint16_t fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_u16vector(k, fill)

def make_s16vector(k: "size_t", fill: "int16_t") -> "pmt::pmt_t":
    r"""make_s16vector(size_t k, int16_t fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_s16vector(k, fill)

def make_u32vector(k: "size_t", fill: "uint32_t") -> "pmt::pmt_t":
    r"""make_u32vector(size_t k, uint32_t fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_u32vector(k, fill)

def make_s32vector(k: "size_t", fill: "int32_t") -> "pmt::pmt_t":
    r"""make_s32vector(size_t k, int32_t fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_s32vector(k, fill)

def make_u64vector(k: "size_t", fill: "uint64_t") -> "pmt::pmt_t":
    r"""make_u64vector(size_t k, uint64_t fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_u64vector(k, fill)

def make_s64vector(k: "size_t", fill: "int64_t") -> "pmt::pmt_t":
    r"""make_s64vector(size_t k, int64_t fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_s64vector(k, fill)

def make_f32vector(k: "size_t", fill: "float") -> "pmt::pmt_t":
    r"""make_f32vector(size_t k, float fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_f32vector(k, fill)

def make_f64vector(k: "size_t", fill: "double") -> "pmt::pmt_t":
    r"""make_f64vector(size_t k, double fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_f64vector(k, fill)

def make_c32vector(k: "size_t", fill: "std::complex< float >") -> "pmt::pmt_t":
    r"""make_c32vector(size_t k, std::complex< float > fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_c32vector(k, fill)

def make_c64vector(k: "size_t", fill: "std::complex< double >") -> "pmt::pmt_t":
    r"""make_c64vector(size_t k, std::complex< double > fill) -> swig_pmt_ptr"""
    return _pmt_swig.make_c64vector(k, fill)

def init_u8vector(k: "size_t", data: "pmt_vector_uint8") -> "pmt::pmt_t":
    r"""init_u8vector(size_t k, pmt_vector_uint8 data) -> swig_pmt_ptr"""
    return _pmt_swig.init_u8vector(k, data)

def init_s8vector(k: "size_t", data: "pmt_vector_int8") -> "pmt::pmt_t":
    r"""init_s8vector(size_t k, pmt_vector_int8 data) -> swig_pmt_ptr"""
    return _pmt_swig.init_s8vector(k, data)

def init_u16vector(k: "size_t", data: "pmt_vector_uint16") -> "pmt::pmt_t":
    r"""init_u16vector(size_t k, pmt_vector_uint16 data) -> swig_pmt_ptr"""
    return _pmt_swig.init_u16vector(k, data)

def init_s16vector(k: "size_t", data: "pmt_vector_int16") -> "pmt::pmt_t":
    r"""init_s16vector(size_t k, pmt_vector_int16 data) -> swig_pmt_ptr"""
    return _pmt_swig.init_s16vector(k, data)

def init_u32vector(k: "size_t", data: "pmt_vector_uint32") -> "pmt::pmt_t":
    r"""init_u32vector(size_t k, pmt_vector_uint32 data) -> swig_pmt_ptr"""
    return _pmt_swig.init_u32vector(k, data)

def init_s32vector(k: "size_t", data: "pmt_vector_int32") -> "pmt::pmt_t":
    r"""init_s32vector(size_t k, pmt_vector_int32 data) -> swig_pmt_ptr"""
    return _pmt_swig.init_s32vector(k, data)

def init_f32vector(k: "size_t", data: "pmt_vector_float") -> "pmt::pmt_t":
    r"""init_f32vector(size_t k, pmt_vector_float data) -> swig_pmt_ptr"""
    return _pmt_swig.init_f32vector(k, data)

def init_f64vector(k: "size_t", data: "pmt_vector_double") -> "pmt::pmt_t":
    r"""init_f64vector(size_t k, pmt_vector_double data) -> swig_pmt_ptr"""
    return _pmt_swig.init_f64vector(k, data)

def init_c32vector(k: "size_t", data: "pmt_vector_cfloat") -> "pmt::pmt_t":
    r"""init_c32vector(size_t k, pmt_vector_cfloat data) -> swig_pmt_ptr"""
    return _pmt_swig.init_c32vector(k, data)

def init_c64vector(k: "size_t", data: "pmt_vector_cdouble") -> "pmt::pmt_t":
    r"""init_c64vector(size_t k, pmt_vector_cdouble data) -> swig_pmt_ptr"""
    return _pmt_swig.init_c64vector(k, data)

def u8vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "uint8_t":
    r"""u8vector_ref(swig_pmt_ptr v, size_t k) -> uint8_t"""
    return _pmt_swig.u8vector_ref(v, k)

def s8vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "int8_t":
    r"""s8vector_ref(swig_pmt_ptr v, size_t k) -> int8_t"""
    return _pmt_swig.s8vector_ref(v, k)

def u16vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "uint16_t":
    r"""u16vector_ref(swig_pmt_ptr v, size_t k) -> uint16_t"""
    return _pmt_swig.u16vector_ref(v, k)

def s16vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "int16_t":
    r"""s16vector_ref(swig_pmt_ptr v, size_t k) -> int16_t"""
    return _pmt_swig.s16vector_ref(v, k)

def u32vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "uint32_t":
    r"""u32vector_ref(swig_pmt_ptr v, size_t k) -> uint32_t"""
    return _pmt_swig.u32vector_ref(v, k)

def s32vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "int32_t":
    r"""s32vector_ref(swig_pmt_ptr v, size_t k) -> int32_t"""
    return _pmt_swig.s32vector_ref(v, k)

def u64vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "uint64_t":
    r"""u64vector_ref(swig_pmt_ptr v, size_t k) -> uint64_t"""
    return _pmt_swig.u64vector_ref(v, k)

def s64vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "int64_t":
    r"""s64vector_ref(swig_pmt_ptr v, size_t k) -> int64_t"""
    return _pmt_swig.s64vector_ref(v, k)

def f32vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "float":
    r"""f32vector_ref(swig_pmt_ptr v, size_t k) -> float"""
    return _pmt_swig.f32vector_ref(v, k)

def f64vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "double":
    r"""f64vector_ref(swig_pmt_ptr v, size_t k) -> double"""
    return _pmt_swig.f64vector_ref(v, k)

def c32vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "std::complex< float >":
    r"""c32vector_ref(swig_pmt_ptr v, size_t k) -> std::complex< float >"""
    return _pmt_swig.c32vector_ref(v, k)

def c64vector_ref(v: "swig_pmt_ptr", k: "size_t") -> "std::complex< double >":
    r"""c64vector_ref(swig_pmt_ptr v, size_t k) -> std::complex< double >"""
    return _pmt_swig.c64vector_ref(v, k)

def u8vector_set(v: "swig_pmt_ptr", k: "size_t", x: "uint8_t") -> "void":
    r"""u8vector_set(swig_pmt_ptr v, size_t k, uint8_t x)"""
    return _pmt_swig.u8vector_set(v, k, x)

def s8vector_set(v: "swig_pmt_ptr", k: "size_t", x: "int8_t") -> "void":
    r"""s8vector_set(swig_pmt_ptr v, size_t k, int8_t x)"""
    return _pmt_swig.s8vector_set(v, k, x)

def u16vector_set(v: "swig_pmt_ptr", k: "size_t", x: "uint16_t") -> "void":
    r"""u16vector_set(swig_pmt_ptr v, size_t k, uint16_t x)"""
    return _pmt_swig.u16vector_set(v, k, x)

def s16vector_set(v: "swig_pmt_ptr", k: "size_t", x: "int16_t") -> "void":
    r"""s16vector_set(swig_pmt_ptr v, size_t k, int16_t x)"""
    return _pmt_swig.s16vector_set(v, k, x)

def u32vector_set(v: "swig_pmt_ptr", k: "size_t", x: "uint32_t") -> "void":
    r"""u32vector_set(swig_pmt_ptr v, size_t k, uint32_t x)"""
    return _pmt_swig.u32vector_set(v, k, x)

def s32vector_set(v: "swig_pmt_ptr", k: "size_t", x: "int32_t") -> "void":
    r"""s32vector_set(swig_pmt_ptr v, size_t k, int32_t x)"""
    return _pmt_swig.s32vector_set(v, k, x)

def u64vector_set(v: "swig_pmt_ptr", k: "size_t", x: "uint64_t") -> "void":
    r"""u64vector_set(swig_pmt_ptr v, size_t k, uint64_t x)"""
    return _pmt_swig.u64vector_set(v, k, x)

def s64vector_set(v: "swig_pmt_ptr", k: "size_t", x: "int64_t") -> "void":
    r"""s64vector_set(swig_pmt_ptr v, size_t k, int64_t x)"""
    return _pmt_swig.s64vector_set(v, k, x)

def f32vector_set(v: "swig_pmt_ptr", k: "size_t", x: "float") -> "void":
    r"""f32vector_set(swig_pmt_ptr v, size_t k, float x)"""
    return _pmt_swig.f32vector_set(v, k, x)

def f64vector_set(v: "swig_pmt_ptr", k: "size_t", x: "double") -> "void":
    r"""f64vector_set(swig_pmt_ptr v, size_t k, double x)"""
    return _pmt_swig.f64vector_set(v, k, x)

def c32vector_set(v: "swig_pmt_ptr", k: "size_t", x: "std::complex< float >") -> "void":
    r"""c32vector_set(swig_pmt_ptr v, size_t k, std::complex< float > x)"""
    return _pmt_swig.c32vector_set(v, k, x)

def c64vector_set(v: "swig_pmt_ptr", k: "size_t", x: "std::complex< double >") -> "void":
    r"""c64vector_set(swig_pmt_ptr v, size_t k, std::complex< double > x)"""
    return _pmt_swig.c64vector_set(v, k, x)

def uniform_vector_elements(v: "swig_pmt_ptr", len: "size_t &") -> "size_t &":
    r"""uniform_vector_elements(swig_pmt_ptr v, size_t & len) -> void const *"""
    return _pmt_swig.uniform_vector_elements(v, len)

def u8vector_elements(v: "swig_pmt_ptr") -> "std::vector< uint8_t,std::allocator< uint8_t > > const":
    r"""u8vector_elements(swig_pmt_ptr v) -> pmt_vector_uint8"""
    return _pmt_swig.u8vector_elements(v)

def s8vector_elements(v: "swig_pmt_ptr") -> "std::vector< int8_t,std::allocator< int8_t > > const":
    r"""s8vector_elements(swig_pmt_ptr v) -> pmt_vector_int8"""
    return _pmt_swig.s8vector_elements(v)

def u16vector_elements(v: "swig_pmt_ptr") -> "std::vector< uint16_t,std::allocator< uint16_t > > const":
    r"""u16vector_elements(swig_pmt_ptr v) -> pmt_vector_uint16"""
    return _pmt_swig.u16vector_elements(v)

def s16vector_elements(v: "swig_pmt_ptr") -> "std::vector< int16_t,std::allocator< int16_t > > const":
    r"""s16vector_elements(swig_pmt_ptr v) -> pmt_vector_int16"""
    return _pmt_swig.s16vector_elements(v)

def u32vector_elements(v: "swig_pmt_ptr") -> "std::vector< uint32_t,std::allocator< uint32_t > > const":
    r"""u32vector_elements(swig_pmt_ptr v) -> pmt_vector_uint32"""
    return _pmt_swig.u32vector_elements(v)

def s32vector_elements(v: "swig_pmt_ptr") -> "std::vector< int32_t,std::allocator< int32_t > > const":
    r"""s32vector_elements(swig_pmt_ptr v) -> pmt_vector_int32"""
    return _pmt_swig.s32vector_elements(v)

def f32vector_elements(v: "swig_pmt_ptr") -> "std::vector< float,std::allocator< float > > const":
    r"""f32vector_elements(swig_pmt_ptr v) -> pmt_vector_float"""
    return _pmt_swig.f32vector_elements(v)

def f64vector_elements(v: "swig_pmt_ptr") -> "std::vector< double,std::allocator< double > > const":
    r"""f64vector_elements(swig_pmt_ptr v) -> pmt_vector_double"""
    return _pmt_swig.f64vector_elements(v)

def c32vector_elements(v: "swig_pmt_ptr") -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > > const":
    r"""c32vector_elements(swig_pmt_ptr v) -> pmt_vector_cfloat"""
    return _pmt_swig.c32vector_elements(v)

def c64vector_elements(v: "swig_pmt_ptr") -> "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const":
    r"""c64vector_elements(swig_pmt_ptr v) -> pmt_vector_cdouble"""
    return _pmt_swig.c64vector_elements(v)

def is_dict(obj: "swig_pmt_ptr") -> "bool":
    r"""is_dict(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_dict(obj)

def make_dict() -> "pmt::pmt_t":
    r"""make_dict() -> swig_pmt_ptr"""
    return _pmt_swig.make_dict()

def dict_add(dict: "swig_pmt_ptr", key: "swig_pmt_ptr", value: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""dict_add(swig_pmt_ptr dict, swig_pmt_ptr key, swig_pmt_ptr value) -> swig_pmt_ptr"""
    return _pmt_swig.dict_add(dict, key, value)

def dict_delete(dict: "swig_pmt_ptr", key: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""dict_delete(swig_pmt_ptr dict, swig_pmt_ptr key) -> swig_pmt_ptr"""
    return _pmt_swig.dict_delete(dict, key)

def dict_has_key(dict: "swig_pmt_ptr", key: "swig_pmt_ptr") -> "bool":
    r"""dict_has_key(swig_pmt_ptr dict, swig_pmt_ptr key) -> bool"""
    return _pmt_swig.dict_has_key(dict, key)

def dict_ref(dict: "swig_pmt_ptr", key: "swig_pmt_ptr", not_found: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""dict_ref(swig_pmt_ptr dict, swig_pmt_ptr key, swig_pmt_ptr not_found) -> swig_pmt_ptr"""
    return _pmt_swig.dict_ref(dict, key, not_found)

def dict_items(dict: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""dict_items(swig_pmt_ptr dict) -> swig_pmt_ptr"""
    return _pmt_swig.dict_items(dict)

def dict_keys(dict: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""dict_keys(swig_pmt_ptr dict) -> swig_pmt_ptr"""
    return _pmt_swig.dict_keys(dict)

def dict_update(dict1: "swig_pmt_ptr", dict2: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""dict_update(swig_pmt_ptr dict1, swig_pmt_ptr dict2) -> swig_pmt_ptr"""
    return _pmt_swig.dict_update(dict1, dict2)

def dict_values(dict: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""dict_values(swig_pmt_ptr dict) -> swig_pmt_ptr"""
    return _pmt_swig.dict_values(dict)

def is_any(obj: "swig_pmt_ptr") -> "bool":
    r"""is_any(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_any(obj)

def make_any(any: "boost::any const &") -> "pmt::pmt_t":
    r"""make_any(boost::any const & any) -> swig_pmt_ptr"""
    return _pmt_swig.make_any(any)

def any_ref(obj: "swig_pmt_ptr") -> "boost::any":
    r"""any_ref(swig_pmt_ptr obj) -> boost::any"""
    return _pmt_swig.any_ref(obj)

def any_set(obj: "swig_pmt_ptr", any: "boost::any const &") -> "void":
    r"""any_set(swig_pmt_ptr obj, boost::any const & any)"""
    return _pmt_swig.any_set(obj, any)

def is_msg_accepter(obj: "swig_pmt_ptr") -> "bool":
    r"""is_msg_accepter(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_msg_accepter(obj)

def make_msg_accepter(ma: "boost::shared_ptr< gr::messages::msg_accepter >") -> "pmt::pmt_t":
    r"""make_msg_accepter(boost::shared_ptr< gr::messages::msg_accepter > ma) -> swig_pmt_ptr"""
    return _pmt_swig.make_msg_accepter(ma)

def msg_accepter_ref(obj: "swig_pmt_ptr") -> "boost::shared_ptr< gr::messages::msg_accepter >":
    r"""msg_accepter_ref(swig_pmt_ptr obj) -> boost::shared_ptr< gr::messages::msg_accepter >"""
    return _pmt_swig.msg_accepter_ref(obj)

def eq(x: "swig_pmt_ptr", y: "swig_pmt_ptr") -> "bool":
    r"""eq(swig_pmt_ptr x, swig_pmt_ptr y) -> bool"""
    return _pmt_swig.eq(x, y)

def eqv(x: "swig_pmt_ptr", y: "swig_pmt_ptr") -> "bool":
    r"""eqv(swig_pmt_ptr x, swig_pmt_ptr y) -> bool"""
    return _pmt_swig.eqv(x, y)

def equal(x: "swig_pmt_ptr", y: "swig_pmt_ptr") -> "bool":
    r"""equal(swig_pmt_ptr x, swig_pmt_ptr y) -> bool"""
    return _pmt_swig.equal(x, y)

def length(v: "swig_pmt_ptr") -> "size_t":
    r"""length(swig_pmt_ptr v) -> size_t"""
    return _pmt_swig.length(v)

def assq(obj: "swig_pmt_ptr", alist: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""assq(swig_pmt_ptr obj, swig_pmt_ptr alist) -> swig_pmt_ptr"""
    return _pmt_swig.assq(obj, alist)

def assv(obj: "swig_pmt_ptr", alist: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""assv(swig_pmt_ptr obj, swig_pmt_ptr alist) -> swig_pmt_ptr"""
    return _pmt_swig.assv(obj, alist)

def assoc(obj: "swig_pmt_ptr", alist: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""assoc(swig_pmt_ptr obj, swig_pmt_ptr alist) -> swig_pmt_ptr"""
    return _pmt_swig.assoc(obj, alist)

def map(proc: "pmt::pmt_t (*)(pmt::pmt_t const &)", list: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""map(pmt::pmt_t (*)(pmt::pmt_t const &) proc, swig_pmt_ptr list) -> swig_pmt_ptr"""
    return _pmt_swig.map(proc, list)

def reverse(list: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""reverse(swig_pmt_ptr list) -> swig_pmt_ptr"""
    return _pmt_swig.reverse(list)

def reverse_x(list: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""reverse_x(swig_pmt_ptr list) -> swig_pmt_ptr"""
    return _pmt_swig.reverse_x(list)

def acons(x: "swig_pmt_ptr", y: "swig_pmt_ptr", a: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""acons(swig_pmt_ptr x, swig_pmt_ptr y, swig_pmt_ptr a) -> swig_pmt_ptr"""
    return _pmt_swig.acons(x, y, a)

def nth(n: "size_t", list: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""nth(size_t n, swig_pmt_ptr list) -> swig_pmt_ptr"""
    return _pmt_swig.nth(n, list)

def nthcdr(n: "size_t", list: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""nthcdr(size_t n, swig_pmt_ptr list) -> swig_pmt_ptr"""
    return _pmt_swig.nthcdr(n, list)

def memq(obj: "swig_pmt_ptr", list: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""memq(swig_pmt_ptr obj, swig_pmt_ptr list) -> swig_pmt_ptr"""
    return _pmt_swig.memq(obj, list)

def memv(obj: "swig_pmt_ptr", list: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""memv(swig_pmt_ptr obj, swig_pmt_ptr list) -> swig_pmt_ptr"""
    return _pmt_swig.memv(obj, list)

def member(obj: "swig_pmt_ptr", list: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""member(swig_pmt_ptr obj, swig_pmt_ptr list) -> swig_pmt_ptr"""
    return _pmt_swig.member(obj, list)

def subsetp(list1: "swig_pmt_ptr", list2: "swig_pmt_ptr") -> "bool":
    r"""subsetp(swig_pmt_ptr list1, swig_pmt_ptr list2) -> bool"""
    return _pmt_swig.subsetp(list1, list2)

def list1(x1: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""list1(swig_pmt_ptr x1) -> swig_pmt_ptr"""
    return _pmt_swig.list1(x1)

def list2(x1: "swig_pmt_ptr", x2: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""list2(swig_pmt_ptr x1, swig_pmt_ptr x2) -> swig_pmt_ptr"""
    return _pmt_swig.list2(x1, x2)

def list3(x1: "swig_pmt_ptr", x2: "swig_pmt_ptr", x3: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""list3(swig_pmt_ptr x1, swig_pmt_ptr x2, swig_pmt_ptr x3) -> swig_pmt_ptr"""
    return _pmt_swig.list3(x1, x2, x3)

def list4(x1: "swig_pmt_ptr", x2: "swig_pmt_ptr", x3: "swig_pmt_ptr", x4: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""list4(swig_pmt_ptr x1, swig_pmt_ptr x2, swig_pmt_ptr x3, swig_pmt_ptr x4) -> swig_pmt_ptr"""
    return _pmt_swig.list4(x1, x2, x3, x4)

def list5(x1: "swig_pmt_ptr", x2: "swig_pmt_ptr", x3: "swig_pmt_ptr", x4: "swig_pmt_ptr", x5: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""list5(swig_pmt_ptr x1, swig_pmt_ptr x2, swig_pmt_ptr x3, swig_pmt_ptr x4, swig_pmt_ptr x5) -> swig_pmt_ptr"""
    return _pmt_swig.list5(x1, x2, x3, x4, x5)

def list6(x1: "swig_pmt_ptr", x2: "swig_pmt_ptr", x3: "swig_pmt_ptr", x4: "swig_pmt_ptr", x5: "swig_pmt_ptr", x6: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""list6(swig_pmt_ptr x1, swig_pmt_ptr x2, swig_pmt_ptr x3, swig_pmt_ptr x4, swig_pmt_ptr x5, swig_pmt_ptr x6) -> swig_pmt_ptr"""
    return _pmt_swig.list6(x1, x2, x3, x4, x5, x6)

def list_add(list: "swig_pmt_ptr", item: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""list_add(swig_pmt_ptr list, swig_pmt_ptr item) -> swig_pmt_ptr"""
    return _pmt_swig.list_add(list, item)

def list_rm(list: "swig_pmt_ptr", item: "swig_pmt_ptr") -> "pmt::pmt_t":
    r"""list_rm(swig_pmt_ptr list, swig_pmt_ptr item) -> swig_pmt_ptr"""
    return _pmt_swig.list_rm(list, item)

def list_has(list: "swig_pmt_ptr", item: "swig_pmt_ptr") -> "bool":
    r"""list_has(swig_pmt_ptr list, swig_pmt_ptr item) -> bool"""
    return _pmt_swig.list_has(list, item)

def is_eof_object(obj: "swig_pmt_ptr") -> "bool":
    r"""is_eof_object(swig_pmt_ptr obj) -> bool"""
    return _pmt_swig.is_eof_object(obj)

def read(port: "std::istream &") -> "pmt::pmt_t":
    r"""read(std::istream & port) -> swig_pmt_ptr"""
    return _pmt_swig.read(port)

def write(obj: "swig_pmt_ptr", port: "std::ostream &") -> "void":
    r"""write(swig_pmt_ptr obj, std::ostream & port)"""
    return _pmt_swig.write(obj, port)

def write_string(obj: "swig_pmt_ptr") -> "std::string":
    r"""write_string(swig_pmt_ptr obj) -> std::string"""
    return _pmt_swig.write_string(obj)

def serialize(obj: "swig_pmt_ptr", sink: "std::streambuf &") -> "bool":
    r"""serialize(swig_pmt_ptr obj, std::streambuf & sink) -> bool"""
    return _pmt_swig.serialize(obj, sink)

def deserialize(source: "std::streambuf &") -> "pmt::pmt_t":
    r"""deserialize(std::streambuf & source) -> swig_pmt_ptr"""
    return _pmt_swig.deserialize(source)

def dump_sizeof() -> "void":
    r"""dump_sizeof()"""
    return _pmt_swig.dump_sizeof()

def _serialize_str_u8(obj: "swig_pmt_ptr") -> "std::vector< uint8_t,std::allocator< uint8_t > >":
    r"""_serialize_str_u8(swig_pmt_ptr obj) -> pmt_vector_uint8"""
    return _pmt_swig._serialize_str_u8(obj)

def _deserialize_str_u8(py_str: "pmt_vector_uint8") -> "pmt::pmt_t":
    r"""_deserialize_str_u8(pmt_vector_uint8 py_str) -> swig_pmt_ptr"""
    return _pmt_swig._deserialize_str_u8(py_str)

def _serialize_str(obj: "swig_pmt_ptr") -> "std::string":
    r"""_serialize_str(swig_pmt_ptr obj) -> std::string"""
    return _pmt_swig._serialize_str(obj)

def _deserialize_str(str: "std::string") -> "pmt::pmt_t":
    r"""_deserialize_str(std::string str) -> swig_pmt_ptr"""
    return _pmt_swig._deserialize_str(str)

def serialize_str(pmt_obj):
  import sys
  if sys.version_info.major == 2:
    return _serialize_str(pmt_obj)
  import array
  return array.array('B', _serialize_str_u8(pmt_obj)).tobytes()

def deserialize_str(pmt_str):
  import sys
  if sys.version_info.major == 2:
    return _deserialize_str(pmt_str)
  return _deserialize_str_u8(tuple(x for x in pmt_str))




