# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# 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 _osmosdr_swig
else:
    import _osmosdr_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__)



def high_res_timer_now() -> "gr::high_res_timer_type":
    r"""high_res_timer_now() -> gr::high_res_timer_type"""
    return _osmosdr_swig.high_res_timer_now()

def high_res_timer_now_perfmon() -> "gr::high_res_timer_type":
    r"""high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _osmosdr_swig.high_res_timer_now_perfmon()

def high_res_timer_tps() -> "gr::high_res_timer_type":
    r"""high_res_timer_tps() -> gr::high_res_timer_type"""
    return _osmosdr_swig.high_res_timer_tps()

def high_res_timer_epoch() -> "gr::high_res_timer_type":
    r"""high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _osmosdr_swig.high_res_timer_epoch()
class string_vector_t(object):
    r"""Proxy of C++ std::vector< std::string > 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(string_vector_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_vector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t___bool__(self)

    def __len__(self) -> "std::vector< std::string >::size_type":
        r"""__len__(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t___len__(self)

    def __getslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "std::vector< std::string,std::allocator< std::string > > *":
        r"""__getslice__(string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> std::vector< std::string,std::allocator< std::string > > *"""
        return _osmosdr_swig.string_vector_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, std::vector< std::string,std::allocator< std::string > > const & v)
        """
        return _osmosdr_swig.string_vector_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "void":
        r"""__delslice__(string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _osmosdr_swig.string_vector_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(string_vector_t self, std::vector< std::string >::difference_type i)
        __delitem__(string_vector_t self, PySliceObject * slice)
        """
        return _osmosdr_swig.string_vector_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::string >::value_type const &":
        r"""
        __getitem__(string_vector_t self, PySliceObject * slice) -> std::vector< std::string,std::allocator< std::string > >
        __getitem__(string_vector_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _osmosdr_swig.string_vector_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(string_vector_t self, PySliceObject * slice, std::vector< std::string,std::allocator< std::string > > const & v)
        __setitem__(string_vector_t self, PySliceObject * slice)
        __setitem__(string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _osmosdr_swig.string_vector_t___setitem__(self, *args)

    def pop(self) -> "std::vector< std::string >::value_type":
        r"""pop(string_vector_t self) -> std::vector< std::string >::value_type"""
        return _osmosdr_swig.string_vector_t_pop(self)

    def append(self, x: "std::vector< std::string >::value_type const &") -> "void":
        r"""append(string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _osmosdr_swig.string_vector_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t_empty(self)

    def size(self) -> "std::vector< std::string >::size_type":
        r"""size(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t_size(self)

    def swap(self, v: "std::vector< std::string > &") -> "void":
        r"""swap(string_vector_t self, std::vector< std::string > & v)"""
        return _osmosdr_swig.string_vector_t_swap(self, v)

    def begin(self) -> "std::vector< std::string >::iterator":
        r"""begin(string_vector_t self) -> std::vector< std::string >::iterator"""
        return _osmosdr_swig.string_vector_t_begin(self)

    def end(self) -> "std::vector< std::string >::iterator":
        r"""end(string_vector_t self) -> std::vector< std::string >::iterator"""
        return _osmosdr_swig.string_vector_t_end(self)

    def rbegin(self) -> "std::vector< std::string >::reverse_iterator":
        r"""rbegin(string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _osmosdr_swig.string_vector_t_rbegin(self)

    def rend(self) -> "std::vector< std::string >::reverse_iterator":
        r"""rend(string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _osmosdr_swig.string_vector_t_rend(self)

    def clear(self) -> "void":
        r"""clear(string_vector_t self)"""
        return _osmosdr_swig.string_vector_t_clear(self)

    def get_allocator(self) -> "std::vector< std::string >::allocator_type":
        r"""get_allocator(string_vector_t self) -> std::vector< std::string >::allocator_type"""
        return _osmosdr_swig.string_vector_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(string_vector_t self)"""
        return _osmosdr_swig.string_vector_t_pop_back(self)

    def erase(self, *args) -> "std::vector< std::string >::iterator":
        r"""
        erase(string_vector_t self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(string_vector_t self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _osmosdr_swig.string_vector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(string_vector_t self) -> string_vector_t
        __init__(string_vector_t self, std::vector< std::string > const & other) -> string_vector_t
        __init__(string_vector_t self, std::vector< std::string >::size_type size) -> string_vector_t
        __init__(string_vector_t self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> string_vector_t
        """
        _osmosdr_swig.string_vector_t_swiginit(self, _osmosdr_swig.new_string_vector_t(*args))

    def push_back(self, x: "std::vector< std::string >::value_type const &") -> "void":
        r"""push_back(string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _osmosdr_swig.string_vector_t_push_back(self, x)

    def front(self) -> "std::vector< std::string >::value_type const &":
        r"""front(string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _osmosdr_swig.string_vector_t_front(self)

    def back(self) -> "std::vector< std::string >::value_type const &":
        r"""back(string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _osmosdr_swig.string_vector_t_back(self)

    def assign(self, n: "std::vector< std::string >::size_type", x: "std::vector< std::string >::value_type const &") -> "void":
        r"""assign(string_vector_t self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _osmosdr_swig.string_vector_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(string_vector_t self, std::vector< std::string >::size_type new_size)
        resize(string_vector_t self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _osmosdr_swig.string_vector_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(string_vector_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(string_vector_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _osmosdr_swig.string_vector_t_insert(self, *args)

    def reserve(self, n: "std::vector< std::string >::size_type") -> "void":
        r"""reserve(string_vector_t self, std::vector< std::string >::size_type n)"""
        return _osmosdr_swig.string_vector_t_reserve(self, n)

    def capacity(self) -> "std::vector< std::string >::size_type":
        r"""capacity(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t_capacity(self)
    __swig_destroy__ = _osmosdr_swig.delete_string_vector_t

# Register string_vector_t in _osmosdr_swig:
_osmosdr_swig.string_vector_t_swigregister(string_vector_t)

class string_string_dict_t(object):
    r"""Proxy of C++ std::map< std::string,std::string > 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(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t___bool__(self)

    def __len__(self) -> "std::map< std::string,std::string >::size_type":
        r"""__len__(string_string_dict_t self) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::mapped_type const &":
        r"""__getitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _osmosdr_swig.string_string_dict_t___getitem__(self, key)

    def __delitem__(self, key: "std::map< std::string,std::string >::key_type const &") -> "void":
        r"""__delitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key)"""
        return _osmosdr_swig.string_string_dict_t___delitem__(self, key)

    def has_key(self, key: "std::map< std::string,std::string >::key_type const &") -> "bool":
        r"""has_key(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _osmosdr_swig.string_string_dict_t_has_key(self, key)

    def keys(self) -> "PyObject *":
        r"""keys(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_keys(self)

    def values(self) -> "PyObject *":
        r"""values(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_values(self)

    def items(self) -> "PyObject *":
        r"""items(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_items(self)

    def __contains__(self, key: "std::map< std::string,std::string >::key_type const &") -> "bool":
        r"""__contains__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _osmosdr_swig.string_string_dict_t___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        r"""key_iterator(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        r"""value_iterator(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _osmosdr_swig.string_string_dict_t___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        r"""asdict(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(string_string_dict_t self, std::less< std::string > const & other) -> string_string_dict_t
        __init__(string_string_dict_t self) -> string_string_dict_t
        __init__(string_string_dict_t self, string_string_dict_t other) -> string_string_dict_t
        """
        _osmosdr_swig.string_string_dict_t_swiginit(self, _osmosdr_swig.new_string_string_dict_t(*args))

    def empty(self) -> "bool":
        r"""empty(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t_empty(self)

    def size(self) -> "std::map< std::string,std::string >::size_type":
        r"""size(string_string_dict_t self) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t_size(self)

    def swap(self, v: "string_string_dict_t") -> "void":
        r"""swap(string_string_dict_t self, string_string_dict_t v)"""
        return _osmosdr_swig.string_string_dict_t_swap(self, v)

    def begin(self) -> "std::map< std::string,std::string >::iterator":
        r"""begin(string_string_dict_t self) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_begin(self)

    def end(self) -> "std::map< std::string,std::string >::iterator":
        r"""end(string_string_dict_t self) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_end(self)

    def rbegin(self) -> "std::map< std::string,std::string >::reverse_iterator":
        r"""rbegin(string_string_dict_t self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _osmosdr_swig.string_string_dict_t_rbegin(self)

    def rend(self) -> "std::map< std::string,std::string >::reverse_iterator":
        r"""rend(string_string_dict_t self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _osmosdr_swig.string_string_dict_t_rend(self)

    def clear(self) -> "void":
        r"""clear(string_string_dict_t self)"""
        return _osmosdr_swig.string_string_dict_t_clear(self)

    def get_allocator(self) -> "std::map< std::string,std::string >::allocator_type":
        r"""get_allocator(string_string_dict_t self) -> std::map< std::string,std::string >::allocator_type"""
        return _osmosdr_swig.string_string_dict_t_get_allocator(self)

    def count(self, x: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::size_type":
        r"""count(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t_count(self, x)

    def erase(self, *args) -> "void":
        r"""
        erase(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(string_string_dict_t self, std::map< std::string,std::string >::iterator position)
        erase(string_string_dict_t self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _osmosdr_swig.string_string_dict_t_erase(self, *args)

    def find(self, x: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::iterator":
        r"""find(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_find(self, x)

    def lower_bound(self, x: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::iterator":
        r"""lower_bound(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_lower_bound(self, x)

    def upper_bound(self, x: "std::map< std::string,std::string >::key_type const &") -> "std::map< std::string,std::string >::iterator":
        r"""upper_bound(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_upper_bound(self, x)
    __swig_destroy__ = _osmosdr_swig.delete_string_string_dict_t

# Register string_string_dict_t in _osmosdr_swig:
_osmosdr_swig.string_string_dict_t_swigregister(string_string_dict_t)

class devices_t(object):
    r"""Proxy of C++ std::vector< osmosdr::device_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(devices_t self) -> SwigPyIterator"""
        return _osmosdr_swig.devices_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t___bool__(self)

    def __len__(self) -> "std::vector< osmosdr::device_t >::size_type":
        r"""__len__(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t___len__(self)

    def __getslice__(self, i: "std::vector< osmosdr::device_t >::difference_type", j: "std::vector< osmosdr::device_t >::difference_type") -> "std::vector< osmosdr::device_t,std::allocator< osmosdr::device_t > > *":
        r"""__getslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j) -> devices_t"""
        return _osmosdr_swig.devices_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j)
        __setslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j, devices_t v)
        """
        return _osmosdr_swig.devices_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< osmosdr::device_t >::difference_type", j: "std::vector< osmosdr::device_t >::difference_type") -> "void":
        r"""__delslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j)"""
        return _osmosdr_swig.devices_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i)
        __delitem__(devices_t self, PySliceObject * slice)
        """
        return _osmosdr_swig.devices_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< osmosdr::device_t >::value_type const &":
        r"""
        __getitem__(devices_t self, PySliceObject * slice) -> devices_t
        __getitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i) -> device_t
        """
        return _osmosdr_swig.devices_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(devices_t self, PySliceObject * slice, devices_t v)
        __setitem__(devices_t self, PySliceObject * slice)
        __setitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, device_t x)
        """
        return _osmosdr_swig.devices_t___setitem__(self, *args)

    def pop(self) -> "std::vector< osmosdr::device_t >::value_type":
        r"""pop(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_pop(self)

    def append(self, x: "device_t") -> "void":
        r"""append(devices_t self, device_t x)"""
        return _osmosdr_swig.devices_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t_empty(self)

    def size(self) -> "std::vector< osmosdr::device_t >::size_type":
        r"""size(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t_size(self)

    def swap(self, v: "devices_t") -> "void":
        r"""swap(devices_t self, devices_t v)"""
        return _osmosdr_swig.devices_t_swap(self, v)

    def begin(self) -> "std::vector< osmosdr::device_t >::iterator":
        r"""begin(devices_t self) -> std::vector< osmosdr::device_t >::iterator"""
        return _osmosdr_swig.devices_t_begin(self)

    def end(self) -> "std::vector< osmosdr::device_t >::iterator":
        r"""end(devices_t self) -> std::vector< osmosdr::device_t >::iterator"""
        return _osmosdr_swig.devices_t_end(self)

    def rbegin(self) -> "std::vector< osmosdr::device_t >::reverse_iterator":
        r"""rbegin(devices_t self) -> std::vector< osmosdr::device_t >::reverse_iterator"""
        return _osmosdr_swig.devices_t_rbegin(self)

    def rend(self) -> "std::vector< osmosdr::device_t >::reverse_iterator":
        r"""rend(devices_t self) -> std::vector< osmosdr::device_t >::reverse_iterator"""
        return _osmosdr_swig.devices_t_rend(self)

    def clear(self) -> "void":
        r"""clear(devices_t self)"""
        return _osmosdr_swig.devices_t_clear(self)

    def get_allocator(self) -> "std::vector< osmosdr::device_t >::allocator_type":
        r"""get_allocator(devices_t self) -> std::vector< osmosdr::device_t >::allocator_type"""
        return _osmosdr_swig.devices_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(devices_t self)"""
        return _osmosdr_swig.devices_t_pop_back(self)

    def erase(self, *args) -> "std::vector< osmosdr::device_t >::iterator":
        r"""
        erase(devices_t self, std::vector< osmosdr::device_t >::iterator pos) -> std::vector< osmosdr::device_t >::iterator
        erase(devices_t self, std::vector< osmosdr::device_t >::iterator first, std::vector< osmosdr::device_t >::iterator last) -> std::vector< osmosdr::device_t >::iterator
        """
        return _osmosdr_swig.devices_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(devices_t self) -> devices_t
        __init__(devices_t self, devices_t other) -> devices_t
        __init__(devices_t self, std::vector< osmosdr::device_t >::size_type size) -> devices_t
        __init__(devices_t self, std::vector< osmosdr::device_t >::size_type size, device_t value) -> devices_t
        """
        _osmosdr_swig.devices_t_swiginit(self, _osmosdr_swig.new_devices_t(*args))

    def push_back(self, x: "device_t") -> "void":
        r"""push_back(devices_t self, device_t x)"""
        return _osmosdr_swig.devices_t_push_back(self, x)

    def front(self) -> "std::vector< osmosdr::device_t >::value_type const &":
        r"""front(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_front(self)

    def back(self) -> "std::vector< osmosdr::device_t >::value_type const &":
        r"""back(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_back(self)

    def assign(self, n: "std::vector< osmosdr::device_t >::size_type", x: "device_t") -> "void":
        r"""assign(devices_t self, std::vector< osmosdr::device_t >::size_type n, device_t x)"""
        return _osmosdr_swig.devices_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(devices_t self, std::vector< osmosdr::device_t >::size_type new_size)
        resize(devices_t self, std::vector< osmosdr::device_t >::size_type new_size, device_t x)
        """
        return _osmosdr_swig.devices_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(devices_t self, std::vector< osmosdr::device_t >::iterator pos, device_t x) -> std::vector< osmosdr::device_t >::iterator
        insert(devices_t self, std::vector< osmosdr::device_t >::iterator pos, std::vector< osmosdr::device_t >::size_type n, device_t x)
        """
        return _osmosdr_swig.devices_t_insert(self, *args)

    def reserve(self, n: "std::vector< osmosdr::device_t >::size_type") -> "void":
        r"""reserve(devices_t self, std::vector< osmosdr::device_t >::size_type n)"""
        return _osmosdr_swig.devices_t_reserve(self, n)

    def capacity(self) -> "std::vector< osmosdr::device_t >::size_type":
        r"""capacity(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t_capacity(self)
    __swig_destroy__ = _osmosdr_swig.delete_devices_t

# Register devices_t in _osmosdr_swig:
_osmosdr_swig.devices_t_swigregister(devices_t)

class device_t(string_string_dict_t):
    r"""Proxy of C++ osmosdr::device_t 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, **kwargs):
        r"""__init__(device_t self, std::string const & args="") -> device_t"""
        _osmosdr_swig.device_t_swiginit(self, _osmosdr_swig.new_device_t(*args, **kwargs))

    def to_pp_string(self) -> "std::string":
        r"""to_pp_string(device_t self) -> std::string"""
        return _osmosdr_swig.device_t_to_pp_string(self)

    def to_string(self) -> "std::string":
        r"""to_string(device_t self) -> std::string"""
        return _osmosdr_swig.device_t_to_string(self)
    __swig_destroy__ = _osmosdr_swig.delete_device_t

# Register device_t in _osmosdr_swig:
_osmosdr_swig.device_t_swigregister(device_t)

class device(object):
    r"""Proxy of C++ osmosdr::device class."""

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

    @staticmethod
    def find(*args, **kwargs) -> "osmosdr::devices_t":
        r"""find(device_t hint=osmosdr::device_t()) -> devices_t"""
        return _osmosdr_swig.device_find(*args, **kwargs)

    def __init__(self):
        r"""__init__(device self) -> device"""
        _osmosdr_swig.device_swiginit(self, _osmosdr_swig.new_device())
    __swig_destroy__ = _osmosdr_swig.delete_device

# Register device in _osmosdr_swig:
_osmosdr_swig.device_swigregister(device)

def device_find(*args, **kwargs) -> "osmosdr::devices_t":
    r"""device_find(device_t hint=osmosdr::device_t()) -> devices_t"""
    return _osmosdr_swig.device_find(*args, **kwargs)

class range_vector_t(object):
    r"""Proxy of C++ std::vector< osmosdr::range_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(range_vector_t self) -> SwigPyIterator"""
        return _osmosdr_swig.range_vector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(range_vector_t self) -> bool"""
        return _osmosdr_swig.range_vector_t___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(range_vector_t self) -> bool"""
        return _osmosdr_swig.range_vector_t___bool__(self)

    def __len__(self) -> "std::vector< osmosdr::range_t >::size_type":
        r"""__len__(range_vector_t self) -> std::vector< osmosdr::range_t >::size_type"""
        return _osmosdr_swig.range_vector_t___len__(self)

    def __getslice__(self, i: "std::vector< osmosdr::range_t >::difference_type", j: "std::vector< osmosdr::range_t >::difference_type") -> "std::vector< osmosdr::range_t,std::allocator< osmosdr::range_t > > *":
        r"""__getslice__(range_vector_t self, std::vector< osmosdr::range_t >::difference_type i, std::vector< osmosdr::range_t >::difference_type j) -> range_vector_t"""
        return _osmosdr_swig.range_vector_t___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(range_vector_t self, std::vector< osmosdr::range_t >::difference_type i, std::vector< osmosdr::range_t >::difference_type j)
        __setslice__(range_vector_t self, std::vector< osmosdr::range_t >::difference_type i, std::vector< osmosdr::range_t >::difference_type j, range_vector_t v)
        """
        return _osmosdr_swig.range_vector_t___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< osmosdr::range_t >::difference_type", j: "std::vector< osmosdr::range_t >::difference_type") -> "void":
        r"""__delslice__(range_vector_t self, std::vector< osmosdr::range_t >::difference_type i, std::vector< osmosdr::range_t >::difference_type j)"""
        return _osmosdr_swig.range_vector_t___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(range_vector_t self, std::vector< osmosdr::range_t >::difference_type i)
        __delitem__(range_vector_t self, PySliceObject * slice)
        """
        return _osmosdr_swig.range_vector_t___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< osmosdr::range_t >::value_type const &":
        r"""
        __getitem__(range_vector_t self, PySliceObject * slice) -> range_vector_t
        __getitem__(range_vector_t self, std::vector< osmosdr::range_t >::difference_type i) -> range_t
        """
        return _osmosdr_swig.range_vector_t___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(range_vector_t self, PySliceObject * slice, range_vector_t v)
        __setitem__(range_vector_t self, PySliceObject * slice)
        __setitem__(range_vector_t self, std::vector< osmosdr::range_t >::difference_type i, range_t x)
        """
        return _osmosdr_swig.range_vector_t___setitem__(self, *args)

    def pop(self) -> "std::vector< osmosdr::range_t >::value_type":
        r"""pop(range_vector_t self) -> range_t"""
        return _osmosdr_swig.range_vector_t_pop(self)

    def append(self, x: "range_t") -> "void":
        r"""append(range_vector_t self, range_t x)"""
        return _osmosdr_swig.range_vector_t_append(self, x)

    def empty(self) -> "bool":
        r"""empty(range_vector_t self) -> bool"""
        return _osmosdr_swig.range_vector_t_empty(self)

    def size(self) -> "std::vector< osmosdr::range_t >::size_type":
        r"""size(range_vector_t self) -> std::vector< osmosdr::range_t >::size_type"""
        return _osmosdr_swig.range_vector_t_size(self)

    def swap(self, v: "range_vector_t") -> "void":
        r"""swap(range_vector_t self, range_vector_t v)"""
        return _osmosdr_swig.range_vector_t_swap(self, v)

    def begin(self) -> "std::vector< osmosdr::range_t >::iterator":
        r"""begin(range_vector_t self) -> std::vector< osmosdr::range_t >::iterator"""
        return _osmosdr_swig.range_vector_t_begin(self)

    def end(self) -> "std::vector< osmosdr::range_t >::iterator":
        r"""end(range_vector_t self) -> std::vector< osmosdr::range_t >::iterator"""
        return _osmosdr_swig.range_vector_t_end(self)

    def rbegin(self) -> "std::vector< osmosdr::range_t >::reverse_iterator":
        r"""rbegin(range_vector_t self) -> std::vector< osmosdr::range_t >::reverse_iterator"""
        return _osmosdr_swig.range_vector_t_rbegin(self)

    def rend(self) -> "std::vector< osmosdr::range_t >::reverse_iterator":
        r"""rend(range_vector_t self) -> std::vector< osmosdr::range_t >::reverse_iterator"""
        return _osmosdr_swig.range_vector_t_rend(self)

    def clear(self) -> "void":
        r"""clear(range_vector_t self)"""
        return _osmosdr_swig.range_vector_t_clear(self)

    def get_allocator(self) -> "std::vector< osmosdr::range_t >::allocator_type":
        r"""get_allocator(range_vector_t self) -> std::vector< osmosdr::range_t >::allocator_type"""
        return _osmosdr_swig.range_vector_t_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(range_vector_t self)"""
        return _osmosdr_swig.range_vector_t_pop_back(self)

    def erase(self, *args) -> "std::vector< osmosdr::range_t >::iterator":
        r"""
        erase(range_vector_t self, std::vector< osmosdr::range_t >::iterator pos) -> std::vector< osmosdr::range_t >::iterator
        erase(range_vector_t self, std::vector< osmosdr::range_t >::iterator first, std::vector< osmosdr::range_t >::iterator last) -> std::vector< osmosdr::range_t >::iterator
        """
        return _osmosdr_swig.range_vector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(range_vector_t self) -> range_vector_t
        __init__(range_vector_t self, range_vector_t other) -> range_vector_t
        __init__(range_vector_t self, std::vector< osmosdr::range_t >::size_type size) -> range_vector_t
        __init__(range_vector_t self, std::vector< osmosdr::range_t >::size_type size, range_t value) -> range_vector_t
        """
        _osmosdr_swig.range_vector_t_swiginit(self, _osmosdr_swig.new_range_vector_t(*args))

    def push_back(self, x: "range_t") -> "void":
        r"""push_back(range_vector_t self, range_t x)"""
        return _osmosdr_swig.range_vector_t_push_back(self, x)

    def front(self) -> "std::vector< osmosdr::range_t >::value_type const &":
        r"""front(range_vector_t self) -> range_t"""
        return _osmosdr_swig.range_vector_t_front(self)

    def back(self) -> "std::vector< osmosdr::range_t >::value_type const &":
        r"""back(range_vector_t self) -> range_t"""
        return _osmosdr_swig.range_vector_t_back(self)

    def assign(self, n: "std::vector< osmosdr::range_t >::size_type", x: "range_t") -> "void":
        r"""assign(range_vector_t self, std::vector< osmosdr::range_t >::size_type n, range_t x)"""
        return _osmosdr_swig.range_vector_t_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(range_vector_t self, std::vector< osmosdr::range_t >::size_type new_size)
        resize(range_vector_t self, std::vector< osmosdr::range_t >::size_type new_size, range_t x)
        """
        return _osmosdr_swig.range_vector_t_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(range_vector_t self, std::vector< osmosdr::range_t >::iterator pos, range_t x) -> std::vector< osmosdr::range_t >::iterator
        insert(range_vector_t self, std::vector< osmosdr::range_t >::iterator pos, std::vector< osmosdr::range_t >::size_type n, range_t x)
        """
        return _osmosdr_swig.range_vector_t_insert(self, *args)

    def reserve(self, n: "std::vector< osmosdr::range_t >::size_type") -> "void":
        r"""reserve(range_vector_t self, std::vector< osmosdr::range_t >::size_type n)"""
        return _osmosdr_swig.range_vector_t_reserve(self, n)

    def capacity(self) -> "std::vector< osmosdr::range_t >::size_type":
        r"""capacity(range_vector_t self) -> std::vector< osmosdr::range_t >::size_type"""
        return _osmosdr_swig.range_vector_t_capacity(self)
    __swig_destroy__ = _osmosdr_swig.delete_range_vector_t

# Register range_vector_t in _osmosdr_swig:
_osmosdr_swig.range_vector_t_swigregister(range_vector_t)

class range_t(object):
    r"""Proxy of C++ osmosdr::range_t 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__(range_t self, double value=0) -> range_t
        __init__(range_t self, double start, double stop, double step=0) -> range_t
        """
        _osmosdr_swig.range_t_swiginit(self, _osmosdr_swig.new_range_t(*args))

    def start(self) -> "double":
        r"""start(range_t self) -> double"""
        return _osmosdr_swig.range_t_start(self)

    def stop(self) -> "double":
        r"""stop(range_t self) -> double"""
        return _osmosdr_swig.range_t_stop(self)

    def step(self) -> "double":
        r"""step(range_t self) -> double"""
        return _osmosdr_swig.range_t_step(self)

    def to_pp_string(self) -> "std::string const":
        r"""to_pp_string(range_t self) -> std::string const"""
        return _osmosdr_swig.range_t_to_pp_string(self)
    __swig_destroy__ = _osmosdr_swig.delete_range_t

# Register range_t in _osmosdr_swig:
_osmosdr_swig.range_t_swigregister(range_t)
cvar = _osmosdr_swig.cvar
ALL_MBOARDS = cvar.ALL_MBOARDS
ALL_CHANS = cvar.ALL_CHANS

class meta_range_t(range_vector_t):
    r"""Proxy of C++ osmosdr::meta_range_t 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__(meta_range_t self) -> meta_range_t
        __init__(meta_range_t self, double start, double stop, double step=0) -> meta_range_t
        """
        _osmosdr_swig.meta_range_t_swiginit(self, _osmosdr_swig.new_meta_range_t(*args))

    def start(self) -> "double":
        r"""start(meta_range_t self) -> double"""
        return _osmosdr_swig.meta_range_t_start(self)

    def stop(self) -> "double":
        r"""stop(meta_range_t self) -> double"""
        return _osmosdr_swig.meta_range_t_stop(self)

    def step(self) -> "double":
        r"""step(meta_range_t self) -> double"""
        return _osmosdr_swig.meta_range_t_step(self)

    def clip(self, value: "double", clip_step: "bool"=False) -> "double":
        r"""clip(meta_range_t self, double value, bool clip_step=False) -> double"""
        return _osmosdr_swig.meta_range_t_clip(self, value, clip_step)

    def values(self) -> "std::vector< double,std::allocator< double > >":
        r"""values(meta_range_t self) -> pmt_vector_double"""
        return _osmosdr_swig.meta_range_t_values(self)

    def to_pp_string(self) -> "std::string const":
        r"""to_pp_string(meta_range_t self) -> std::string const"""
        return _osmosdr_swig.meta_range_t_to_pp_string(self)
    __swig_destroy__ = _osmosdr_swig.delete_meta_range_t

# Register meta_range_t in _osmosdr_swig:
_osmosdr_swig.meta_range_t_swigregister(meta_range_t)

class time_spec_t(object):
    r"""Proxy of C++ osmosdr::time_spec_t class."""

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

    @staticmethod
    def get_system_time() -> "osmosdr::time_spec_t":
        r"""get_system_time() -> time_spec_t"""
        return _osmosdr_swig.time_spec_t_get_system_time()

    def __init__(self, *args):
        r"""
        __init__(time_spec_t self, double secs=0) -> time_spec_t
        __init__(time_spec_t self, time_t full_secs, double frac_secs=0) -> time_spec_t
        __init__(time_spec_t self, time_t full_secs, long tick_count, double tick_rate) -> time_spec_t
        """
        _osmosdr_swig.time_spec_t_swiginit(self, _osmosdr_swig.new_time_spec_t(*args))

    @staticmethod
    def from_ticks(ticks: "long long", tick_rate: "double") -> "osmosdr::time_spec_t":
        r"""from_ticks(long long ticks, double tick_rate) -> time_spec_t"""
        return _osmosdr_swig.time_spec_t_from_ticks(ticks, tick_rate)

    def get_tick_count(self, tick_rate: "double") -> "long":
        r"""get_tick_count(time_spec_t self, double tick_rate) -> long"""
        return _osmosdr_swig.time_spec_t_get_tick_count(self, tick_rate)

    def to_ticks(self, tick_rate: "double const") -> "long long":
        r"""to_ticks(time_spec_t self, double const tick_rate) -> long long"""
        return _osmosdr_swig.time_spec_t_to_ticks(self, tick_rate)

    def get_real_secs(self) -> "double":
        r"""get_real_secs(time_spec_t self) -> double"""
        return _osmosdr_swig.time_spec_t_get_real_secs(self)

    def get_full_secs(self) -> "time_t":
        r"""get_full_secs(time_spec_t self) -> time_t"""
        return _osmosdr_swig.time_spec_t_get_full_secs(self)

    def get_frac_secs(self) -> "double":
        r"""get_frac_secs(time_spec_t self) -> double"""
        return _osmosdr_swig.time_spec_t_get_frac_secs(self)

    def __iadd__(self, arg2: "time_spec_t") -> "osmosdr::time_spec_t &":
        r"""__iadd__(time_spec_t self, time_spec_t arg2) -> time_spec_t"""
        return _osmosdr_swig.time_spec_t___iadd__(self, arg2)

    def __isub__(self, arg2: "time_spec_t") -> "osmosdr::time_spec_t &":
        r"""__isub__(time_spec_t self, time_spec_t arg2) -> time_spec_t"""
        return _osmosdr_swig.time_spec_t___isub__(self, arg2)

    def __add__(self, what: "time_spec_t") -> "osmosdr::time_spec_t":
        r"""__add__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _osmosdr_swig.time_spec_t___add__(self, what)

    def __sub__(self, what: "time_spec_t") -> "osmosdr::time_spec_t":
        r"""__sub__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _osmosdr_swig.time_spec_t___sub__(self, what)
    __swig_destroy__ = _osmosdr_swig.delete_time_spec_t

# Register time_spec_t in _osmosdr_swig:
_osmosdr_swig.time_spec_t_swigregister(time_spec_t)

def time_spec_t_get_system_time() -> "osmosdr::time_spec_t":
    r"""time_spec_t_get_system_time() -> time_spec_t"""
    return _osmosdr_swig.time_spec_t_get_system_time()

def time_spec_t_from_ticks(ticks: "long long", tick_rate: "double") -> "osmosdr::time_spec_t":
    r"""time_spec_t_from_ticks(long long ticks, double tick_rate) -> time_spec_t"""
    return _osmosdr_swig.time_spec_t_from_ticks(ticks, tick_rate)


def __eq__(arg1: "time_spec_t", arg2: "time_spec_t") -> "bool":
    r"""__eq__(time_spec_t arg1, time_spec_t arg2) -> bool"""
    return _osmosdr_swig.__eq__(arg1, arg2)

def __lt__(arg1: "time_spec_t", arg2: "time_spec_t") -> "bool":
    r"""__lt__(time_spec_t arg1, time_spec_t arg2) -> bool"""
    return _osmosdr_swig.__lt__(arg1, arg2)
class source(object):
    r"""Proxy of C++ osmosdr::source 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

    @staticmethod
    def make(*args, **kwargs) -> "osmosdr::source::sptr":
        r"""make(std::string const & args="") -> source_sptr"""
        return _osmosdr_swig.source_make(*args, **kwargs)

    def get_num_channels(self) -> "size_t":
        r"""get_num_channels(source self) -> size_t"""
        return _osmosdr_swig.source_get_num_channels(self)

    def seek(self, seek_point: "long", whence: "int", chan: "size_t"=0) -> "bool":
        r"""seek(source self, long seek_point, int whence, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_seek(self, seek_point, whence, chan)

    def get_sample_rates(self) -> "osmosdr::meta_range_t":
        r"""get_sample_rates(source self) -> meta_range_t"""
        return _osmosdr_swig.source_get_sample_rates(self)

    def set_sample_rate(self, rate: "double") -> "double":
        r"""set_sample_rate(source self, double rate) -> double"""
        return _osmosdr_swig.source_set_sample_rate(self, rate)

    def get_sample_rate(self) -> "double":
        r"""get_sample_rate(source self) -> double"""
        return _osmosdr_swig.source_get_sample_rate(self)

    def get_freq_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""get_freq_range(source self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.source_get_freq_range(self, chan)

    def set_center_freq(self, freq: "double", chan: "size_t"=0) -> "double":
        r"""set_center_freq(source self, double freq, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_center_freq(self, freq, chan)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""get_center_freq(source self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_get_center_freq(self, chan)

    def set_freq_corr(self, ppm: "double", chan: "size_t"=0) -> "double":
        r"""set_freq_corr(source self, double ppm, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_freq_corr(self, ppm, chan)

    def get_freq_corr(self, chan: "size_t"=0) -> "double":
        r"""get_freq_corr(source self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_get_freq_corr(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gain_names(source self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "osmosdr::gain_range_t":
        r"""
        get_gain_range(source self, size_t chan=0) -> meta_range_t
        get_gain_range(source self, std::string const & name, size_t chan=0) -> meta_range_t
        """
        return _osmosdr_swig.source_get_gain_range(self, *args)

    def set_gain_mode(self, automatic: "bool", chan: "size_t"=0) -> "bool":
        r"""set_gain_mode(source self, bool automatic, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_set_gain_mode(self, automatic, chan)

    def get_gain_mode(self, chan: "size_t"=0) -> "bool":
        r"""get_gain_mode(source self, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_get_gain_mode(self, chan)

    def set_gain(self, *args) -> "double":
        r"""
        set_gain(source self, double gain, size_t chan=0) -> double
        set_gain(source self, double gain, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.source_set_gain(self, *args)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(source self, size_t chan=0) -> double
        get_gain(source self, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.source_get_gain(self, *args)

    def set_if_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""set_if_gain(source self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_if_gain(self, gain, chan)

    def set_bb_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""set_bb_gain(source self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_bb_gain(self, gain, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_antennas(source self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_get_antennas(self, chan)

    def set_antenna(self, antenna: "std::string const &", chan: "size_t"=0) -> "std::string":
        r"""set_antenna(source self, std::string const & antenna, size_t chan=0) -> std::string"""
        return _osmosdr_swig.source_set_antenna(self, antenna, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""get_antenna(source self, size_t chan=0) -> std::string"""
        return _osmosdr_swig.source_get_antenna(self, chan)
    DCOffsetOff = _osmosdr_swig.source_DCOffsetOff
    
    DCOffsetManual = _osmosdr_swig.source_DCOffsetManual
    
    DCOffsetAutomatic = _osmosdr_swig.source_DCOffsetAutomatic
    

    def set_dc_offset_mode(self, mode: "int", chan: "size_t"=0) -> "void":
        r"""set_dc_offset_mode(source self, int mode, size_t chan=0)"""
        return _osmosdr_swig.source_set_dc_offset_mode(self, mode, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_dc_offset(source self, std::complex< double > const & offset, size_t chan=0)"""
        return _osmosdr_swig.source_set_dc_offset(self, offset, chan)
    IQBalanceOff = _osmosdr_swig.source_IQBalanceOff
    
    IQBalanceManual = _osmosdr_swig.source_IQBalanceManual
    
    IQBalanceAutomatic = _osmosdr_swig.source_IQBalanceAutomatic
    

    def set_iq_balance_mode(self, mode: "int", chan: "size_t"=0) -> "void":
        r"""set_iq_balance_mode(source self, int mode, size_t chan=0)"""
        return _osmosdr_swig.source_set_iq_balance_mode(self, mode, chan)

    def set_iq_balance(self, balance: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_iq_balance(source self, std::complex< double > const & balance, size_t chan=0)"""
        return _osmosdr_swig.source_set_iq_balance(self, balance, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "double":
        r"""set_bandwidth(source self, double bandwidth, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""get_bandwidth(source self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""get_bandwidth_range(source self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.source_get_bandwidth_range(self, chan)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_time_source(source self, std::string const & source, size_t const mboard=0)"""
        return _osmosdr_swig.source_set_time_source(self, source, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""get_time_source(source self, size_t const mboard) -> std::string"""
        return _osmosdr_swig.source_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_time_sources(source self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_clock_source(source self, std::string const & source, size_t const mboard=0)"""
        return _osmosdr_swig.source_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""get_clock_source(source self, size_t const mboard) -> std::string"""
        return _osmosdr_swig.source_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_clock_sources(source self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""get_clock_rate(source self, size_t mboard=0) -> double"""
        return _osmosdr_swig.source_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""set_clock_rate(source self, double rate, size_t mboard=0)"""
        return _osmosdr_swig.source_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""get_time_now(source self, size_t mboard=0) -> time_spec_t"""
        return _osmosdr_swig.source_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""get_time_last_pps(source self, size_t mboard=0) -> time_spec_t"""
        return _osmosdr_swig.source_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_time_now(source self, time_spec_t time_spec, size_t mboard=0)"""
        return _osmosdr_swig.source_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_next_pps(source self, time_spec_t time_spec)"""
        return _osmosdr_swig.source_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_unknown_pps(source self, time_spec_t time_spec)"""
        return _osmosdr_swig.source_set_time_unknown_pps(self, time_spec)
    __swig_destroy__ = _osmosdr_swig.delete_source

# Register source in _osmosdr_swig:
_osmosdr_swig.source_swigregister(source)

def source_make(*args, **kwargs) -> "osmosdr::source::sptr":
    r"""source_make(std::string const & args="") -> source_sptr"""
    return _osmosdr_swig.source_make(*args, **kwargs)

class sink(object):
    r"""Proxy of C++ osmosdr::sink 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

    @staticmethod
    def make(*args, **kwargs) -> "osmosdr::sink::sptr":
        r"""make(std::string const & args="") -> sink_sptr"""
        return _osmosdr_swig.sink_make(*args, **kwargs)

    def get_num_channels(self) -> "size_t":
        r"""get_num_channels(sink self) -> size_t"""
        return _osmosdr_swig.sink_get_num_channels(self)

    def get_sample_rates(self) -> "osmosdr::meta_range_t":
        r"""get_sample_rates(sink self) -> meta_range_t"""
        return _osmosdr_swig.sink_get_sample_rates(self)

    def set_sample_rate(self, rate: "double") -> "double":
        r"""set_sample_rate(sink self, double rate) -> double"""
        return _osmosdr_swig.sink_set_sample_rate(self, rate)

    def get_sample_rate(self) -> "double":
        r"""get_sample_rate(sink self) -> double"""
        return _osmosdr_swig.sink_get_sample_rate(self)

    def get_freq_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""get_freq_range(sink self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.sink_get_freq_range(self, chan)

    def set_center_freq(self, freq: "double", chan: "size_t"=0) -> "double":
        r"""set_center_freq(sink self, double freq, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_center_freq(self, freq, chan)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""get_center_freq(sink self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_get_center_freq(self, chan)

    def set_freq_corr(self, ppm: "double", chan: "size_t"=0) -> "double":
        r"""set_freq_corr(sink self, double ppm, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_freq_corr(self, ppm, chan)

    def get_freq_corr(self, chan: "size_t"=0) -> "double":
        r"""get_freq_corr(sink self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_get_freq_corr(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gain_names(sink self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "osmosdr::gain_range_t":
        r"""
        get_gain_range(sink self, size_t chan=0) -> meta_range_t
        get_gain_range(sink self, std::string const & name, size_t chan=0) -> meta_range_t
        """
        return _osmosdr_swig.sink_get_gain_range(self, *args)

    def set_gain_mode(self, automatic: "bool", chan: "size_t"=0) -> "bool":
        r"""set_gain_mode(sink self, bool automatic, size_t chan=0) -> bool"""
        return _osmosdr_swig.sink_set_gain_mode(self, automatic, chan)

    def get_gain_mode(self, chan: "size_t"=0) -> "bool":
        r"""get_gain_mode(sink self, size_t chan=0) -> bool"""
        return _osmosdr_swig.sink_get_gain_mode(self, chan)

    def set_gain(self, *args) -> "double":
        r"""
        set_gain(sink self, double gain, size_t chan=0) -> double
        set_gain(sink self, double gain, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.sink_set_gain(self, *args)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(sink self, size_t chan=0) -> double
        get_gain(sink self, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.sink_get_gain(self, *args)

    def set_if_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""set_if_gain(sink self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_if_gain(self, gain, chan)

    def set_bb_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""set_bb_gain(sink self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_bb_gain(self, gain, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_antennas(sink self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_get_antennas(self, chan)

    def set_antenna(self, antenna: "std::string const &", chan: "size_t"=0) -> "std::string":
        r"""set_antenna(sink self, std::string const & antenna, size_t chan=0) -> std::string"""
        return _osmosdr_swig.sink_set_antenna(self, antenna, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""get_antenna(sink self, size_t chan=0) -> std::string"""
        return _osmosdr_swig.sink_get_antenna(self, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_dc_offset(sink self, std::complex< double > const & offset, size_t chan=0)"""
        return _osmosdr_swig.sink_set_dc_offset(self, offset, chan)

    def set_iq_balance(self, balance: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_iq_balance(sink self, std::complex< double > const & balance, size_t chan=0)"""
        return _osmosdr_swig.sink_set_iq_balance(self, balance, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "double":
        r"""set_bandwidth(sink self, double bandwidth, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""get_bandwidth(sink self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""get_bandwidth_range(sink self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.sink_get_bandwidth_range(self, chan)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_time_source(sink self, std::string const & source, size_t const mboard=0)"""
        return _osmosdr_swig.sink_set_time_source(self, source, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""get_time_source(sink self, size_t const mboard) -> std::string"""
        return _osmosdr_swig.sink_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_time_sources(sink self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_clock_source(sink self, std::string const & source, size_t const mboard=0)"""
        return _osmosdr_swig.sink_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""get_clock_source(sink self, size_t const mboard) -> std::string"""
        return _osmosdr_swig.sink_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_clock_sources(sink self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""get_clock_rate(sink self, size_t mboard=0) -> double"""
        return _osmosdr_swig.sink_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""set_clock_rate(sink self, double rate, size_t mboard=0)"""
        return _osmosdr_swig.sink_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""get_time_now(sink self, size_t mboard=0) -> time_spec_t"""
        return _osmosdr_swig.sink_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""get_time_last_pps(sink self, size_t mboard=0) -> time_spec_t"""
        return _osmosdr_swig.sink_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_time_now(sink self, time_spec_t time_spec, size_t mboard=0)"""
        return _osmosdr_swig.sink_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_next_pps(sink self, time_spec_t time_spec)"""
        return _osmosdr_swig.sink_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_unknown_pps(sink self, time_spec_t time_spec)"""
        return _osmosdr_swig.sink_set_time_unknown_pps(self, time_spec)
    __swig_destroy__ = _osmosdr_swig.delete_sink

# Register sink in _osmosdr_swig:
_osmosdr_swig.sink_swigregister(sink)

def sink_make(*args, **kwargs) -> "osmosdr::sink::sptr":
    r"""sink_make(std::string const & args="") -> sink_sptr"""
    return _osmosdr_swig.sink_make(*args, **kwargs)

class source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< osmosdr::source > 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__(source_sptr self) -> source_sptr
        __init__(source_sptr self, source p) -> source_sptr
        """
        _osmosdr_swig.source_sptr_swiginit(self, _osmosdr_swig.new_source_sptr(*args))

    def __deref__(self) -> "osmosdr::source *":
        r"""__deref__(source_sptr self) -> source"""
        return _osmosdr_swig.source_sptr___deref__(self)
    __swig_destroy__ = _osmosdr_swig.delete_source_sptr

    def make(self, *args, **kwargs) -> "osmosdr::source::sptr":
        r"""make(source_sptr self, std::string const & args="") -> source_sptr"""
        return _osmosdr_swig.source_sptr_make(self, *args, **kwargs)

    def get_num_channels(self) -> "size_t":
        r"""get_num_channels(source_sptr self) -> size_t"""
        return _osmosdr_swig.source_sptr_get_num_channels(self)

    def seek(self, seek_point: "long", whence: "int", chan: "size_t"=0) -> "bool":
        r"""seek(source_sptr self, long seek_point, int whence, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_sptr_seek(self, seek_point, whence, chan)

    def get_sample_rates(self) -> "osmosdr::meta_range_t":
        r"""get_sample_rates(source_sptr self) -> meta_range_t"""
        return _osmosdr_swig.source_sptr_get_sample_rates(self)

    def set_sample_rate(self, rate: "double") -> "double":
        r"""set_sample_rate(source_sptr self, double rate) -> double"""
        return _osmosdr_swig.source_sptr_set_sample_rate(self, rate)

    def get_sample_rate(self) -> "double":
        r"""get_sample_rate(source_sptr self) -> double"""
        return _osmosdr_swig.source_sptr_get_sample_rate(self)

    def get_freq_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""get_freq_range(source_sptr self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.source_sptr_get_freq_range(self, chan)

    def set_center_freq(self, freq: "double", chan: "size_t"=0) -> "double":
        r"""set_center_freq(source_sptr self, double freq, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_center_freq(self, freq, chan)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""get_center_freq(source_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_get_center_freq(self, chan)

    def set_freq_corr(self, ppm: "double", chan: "size_t"=0) -> "double":
        r"""set_freq_corr(source_sptr self, double ppm, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_freq_corr(self, ppm, chan)

    def get_freq_corr(self, chan: "size_t"=0) -> "double":
        r"""get_freq_corr(source_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_get_freq_corr(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gain_names(source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_sptr_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "osmosdr::gain_range_t":
        r"""
        get_gain_range(source_sptr self, size_t chan=0) -> meta_range_t
        get_gain_range(source_sptr self, std::string const & name, size_t chan=0) -> meta_range_t
        """
        return _osmosdr_swig.source_sptr_get_gain_range(self, *args)

    def set_gain_mode(self, automatic: "bool", chan: "size_t"=0) -> "bool":
        r"""set_gain_mode(source_sptr self, bool automatic, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_sptr_set_gain_mode(self, automatic, chan)

    def get_gain_mode(self, chan: "size_t"=0) -> "bool":
        r"""get_gain_mode(source_sptr self, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_sptr_get_gain_mode(self, chan)

    def set_gain(self, *args) -> "double":
        r"""
        set_gain(source_sptr self, double gain, size_t chan=0) -> double
        set_gain(source_sptr self, double gain, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.source_sptr_set_gain(self, *args)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(source_sptr self, size_t chan=0) -> double
        get_gain(source_sptr self, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.source_sptr_get_gain(self, *args)

    def set_if_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""set_if_gain(source_sptr self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_if_gain(self, gain, chan)

    def set_bb_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""set_bb_gain(source_sptr self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_bb_gain(self, gain, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_antennas(source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_sptr_get_antennas(self, chan)

    def set_antenna(self, antenna: "std::string const &", chan: "size_t"=0) -> "std::string":
        r"""set_antenna(source_sptr self, std::string const & antenna, size_t chan=0) -> std::string"""
        return _osmosdr_swig.source_sptr_set_antenna(self, antenna, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""get_antenna(source_sptr self, size_t chan=0) -> std::string"""
        return _osmosdr_swig.source_sptr_get_antenna(self, chan)

    def set_dc_offset_mode(self, mode: "int", chan: "size_t"=0) -> "void":
        r"""set_dc_offset_mode(source_sptr self, int mode, size_t chan=0)"""
        return _osmosdr_swig.source_sptr_set_dc_offset_mode(self, mode, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_dc_offset(source_sptr self, std::complex< double > const & offset, size_t chan=0)"""
        return _osmosdr_swig.source_sptr_set_dc_offset(self, offset, chan)

    def set_iq_balance_mode(self, mode: "int", chan: "size_t"=0) -> "void":
        r"""set_iq_balance_mode(source_sptr self, int mode, size_t chan=0)"""
        return _osmosdr_swig.source_sptr_set_iq_balance_mode(self, mode, chan)

    def set_iq_balance(self, balance: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_iq_balance(source_sptr self, std::complex< double > const & balance, size_t chan=0)"""
        return _osmosdr_swig.source_sptr_set_iq_balance(self, balance, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "double":
        r"""set_bandwidth(source_sptr self, double bandwidth, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""get_bandwidth(source_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""get_bandwidth_range(source_sptr self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.source_sptr_get_bandwidth_range(self, chan)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_time_source(source_sptr self, std::string const & source, size_t const mboard=0)"""
        return _osmosdr_swig.source_sptr_set_time_source(self, source, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""get_time_source(source_sptr self, size_t const mboard) -> std::string"""
        return _osmosdr_swig.source_sptr_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_time_sources(source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_sptr_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_clock_source(source_sptr self, std::string const & source, size_t const mboard=0)"""
        return _osmosdr_swig.source_sptr_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""get_clock_source(source_sptr self, size_t const mboard) -> std::string"""
        return _osmosdr_swig.source_sptr_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_clock_sources(source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_sptr_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""get_clock_rate(source_sptr self, size_t mboard=0) -> double"""
        return _osmosdr_swig.source_sptr_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""set_clock_rate(source_sptr self, double rate, size_t mboard=0)"""
        return _osmosdr_swig.source_sptr_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""get_time_now(source_sptr self, size_t mboard=0) -> time_spec_t"""
        return _osmosdr_swig.source_sptr_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""get_time_last_pps(source_sptr self, size_t mboard=0) -> time_spec_t"""
        return _osmosdr_swig.source_sptr_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_time_now(source_sptr self, time_spec_t time_spec, size_t mboard=0)"""
        return _osmosdr_swig.source_sptr_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_next_pps(source_sptr self, time_spec_t time_spec)"""
        return _osmosdr_swig.source_sptr_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_unknown_pps(source_sptr self, time_spec_t time_spec)"""
        return _osmosdr_swig.source_sptr_set_time_unknown_pps(self, time_spec)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(source_sptr self, basic_block_sptr block)
        primitive_connect(source_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.source_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(source_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(source_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.source_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(source_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(source_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.source_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(source_sptr self, basic_block_sptr block)
        primitive_disconnect(source_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.source_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(source_sptr self)"""
        return _osmosdr_swig.source_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(source_sptr self)"""
        return _osmosdr_swig.source_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(source_sptr self)"""
        return _osmosdr_swig.source_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(source_sptr self, swig_pmt_ptr port_id)"""
        return _osmosdr_swig.source_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(source_sptr self, swig_pmt_ptr port_id)"""
        return _osmosdr_swig.source_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _osmosdr_swig.source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(source_sptr self)"""
        return _osmosdr_swig.source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _osmosdr_swig.source_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(source_sptr self, std::string level)"""
        return _osmosdr_swig.source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(source_sptr self, int i) -> size_t"""
        return _osmosdr_swig.source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(source_sptr self, size_t max_output_buffer)
        set_max_output_buffer(source_sptr self, int port, size_t max_output_buffer)
        """
        return _osmosdr_swig.source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(source_sptr self, int i) -> size_t"""
        return _osmosdr_swig.source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(source_sptr self, size_t min_output_buffer)
        set_min_output_buffer(source_sptr self, int port, size_t min_output_buffer)
        """
        return _osmosdr_swig.source_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(source_sptr self) -> hier_block2_sptr"""
        return _osmosdr_swig.source_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(source_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(source_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(source_sptr self) -> long"""
        return _osmosdr_swig.source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(source_sptr self) -> basic_block_sptr"""
        return _osmosdr_swig.source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(source_sptr self, int ninputs, int noutputs) -> bool"""
        return _osmosdr_swig.source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(source_sptr self, std::string name)"""
        return _osmosdr_swig.source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _osmosdr_swig.source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(source_sptr self) -> swig_pmt_ptr"""
        return _osmosdr_swig.source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(source_sptr self) -> swig_pmt_ptr"""
        return _osmosdr_swig.source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _osmosdr_swig.source_sptr_message_subscribers(self, which_port)

# Register source_sptr in _osmosdr_swig:
_osmosdr_swig.source_sptr_swigregister(source_sptr)


source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
source = source.make;

class sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< osmosdr::sink > 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__(sink_sptr self) -> sink_sptr
        __init__(sink_sptr self, sink p) -> sink_sptr
        """
        _osmosdr_swig.sink_sptr_swiginit(self, _osmosdr_swig.new_sink_sptr(*args))

    def __deref__(self) -> "osmosdr::sink *":
        r"""__deref__(sink_sptr self) -> sink"""
        return _osmosdr_swig.sink_sptr___deref__(self)
    __swig_destroy__ = _osmosdr_swig.delete_sink_sptr

    def make(self, *args, **kwargs) -> "osmosdr::sink::sptr":
        r"""make(sink_sptr self, std::string const & args="") -> sink_sptr"""
        return _osmosdr_swig.sink_sptr_make(self, *args, **kwargs)

    def get_num_channels(self) -> "size_t":
        r"""get_num_channels(sink_sptr self) -> size_t"""
        return _osmosdr_swig.sink_sptr_get_num_channels(self)

    def get_sample_rates(self) -> "osmosdr::meta_range_t":
        r"""get_sample_rates(sink_sptr self) -> meta_range_t"""
        return _osmosdr_swig.sink_sptr_get_sample_rates(self)

    def set_sample_rate(self, rate: "double") -> "double":
        r"""set_sample_rate(sink_sptr self, double rate) -> double"""
        return _osmosdr_swig.sink_sptr_set_sample_rate(self, rate)

    def get_sample_rate(self) -> "double":
        r"""get_sample_rate(sink_sptr self) -> double"""
        return _osmosdr_swig.sink_sptr_get_sample_rate(self)

    def get_freq_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""get_freq_range(sink_sptr self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.sink_sptr_get_freq_range(self, chan)

    def set_center_freq(self, freq: "double", chan: "size_t"=0) -> "double":
        r"""set_center_freq(sink_sptr self, double freq, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_center_freq(self, freq, chan)

    def get_center_freq(self, chan: "size_t"=0) -> "double":
        r"""get_center_freq(sink_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_get_center_freq(self, chan)

    def set_freq_corr(self, ppm: "double", chan: "size_t"=0) -> "double":
        r"""set_freq_corr(sink_sptr self, double ppm, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_freq_corr(self, ppm, chan)

    def get_freq_corr(self, chan: "size_t"=0) -> "double":
        r"""get_freq_corr(sink_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_get_freq_corr(self, chan)

    def get_gain_names(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_gain_names(sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_sptr_get_gain_names(self, chan)

    def get_gain_range(self, *args) -> "osmosdr::gain_range_t":
        r"""
        get_gain_range(sink_sptr self, size_t chan=0) -> meta_range_t
        get_gain_range(sink_sptr self, std::string const & name, size_t chan=0) -> meta_range_t
        """
        return _osmosdr_swig.sink_sptr_get_gain_range(self, *args)

    def set_gain_mode(self, automatic: "bool", chan: "size_t"=0) -> "bool":
        r"""set_gain_mode(sink_sptr self, bool automatic, size_t chan=0) -> bool"""
        return _osmosdr_swig.sink_sptr_set_gain_mode(self, automatic, chan)

    def get_gain_mode(self, chan: "size_t"=0) -> "bool":
        r"""get_gain_mode(sink_sptr self, size_t chan=0) -> bool"""
        return _osmosdr_swig.sink_sptr_get_gain_mode(self, chan)

    def set_gain(self, *args) -> "double":
        r"""
        set_gain(sink_sptr self, double gain, size_t chan=0) -> double
        set_gain(sink_sptr self, double gain, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.sink_sptr_set_gain(self, *args)

    def get_gain(self, *args) -> "double":
        r"""
        get_gain(sink_sptr self, size_t chan=0) -> double
        get_gain(sink_sptr self, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.sink_sptr_get_gain(self, *args)

    def set_if_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""set_if_gain(sink_sptr self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_if_gain(self, gain, chan)

    def set_bb_gain(self, gain: "double", chan: "size_t"=0) -> "double":
        r"""set_bb_gain(sink_sptr self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_bb_gain(self, gain, chan)

    def get_antennas(self, chan: "size_t"=0) -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_antennas(sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_sptr_get_antennas(self, chan)

    def set_antenna(self, antenna: "std::string const &", chan: "size_t"=0) -> "std::string":
        r"""set_antenna(sink_sptr self, std::string const & antenna, size_t chan=0) -> std::string"""
        return _osmosdr_swig.sink_sptr_set_antenna(self, antenna, chan)

    def get_antenna(self, chan: "size_t"=0) -> "std::string":
        r"""get_antenna(sink_sptr self, size_t chan=0) -> std::string"""
        return _osmosdr_swig.sink_sptr_get_antenna(self, chan)

    def set_dc_offset(self, offset: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_dc_offset(sink_sptr self, std::complex< double > const & offset, size_t chan=0)"""
        return _osmosdr_swig.sink_sptr_set_dc_offset(self, offset, chan)

    def set_iq_balance(self, balance: "std::complex< double > const &", chan: "size_t"=0) -> "void":
        r"""set_iq_balance(sink_sptr self, std::complex< double > const & balance, size_t chan=0)"""
        return _osmosdr_swig.sink_sptr_set_iq_balance(self, balance, chan)

    def set_bandwidth(self, bandwidth: "double", chan: "size_t"=0) -> "double":
        r"""set_bandwidth(sink_sptr self, double bandwidth, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_bandwidth(self, bandwidth, chan)

    def get_bandwidth(self, chan: "size_t"=0) -> "double":
        r"""get_bandwidth(sink_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_get_bandwidth(self, chan)

    def get_bandwidth_range(self, chan: "size_t"=0) -> "osmosdr::freq_range_t":
        r"""get_bandwidth_range(sink_sptr self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.sink_sptr_get_bandwidth_range(self, chan)

    def set_time_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_time_source(sink_sptr self, std::string const & source, size_t const mboard=0)"""
        return _osmosdr_swig.sink_sptr_set_time_source(self, source, mboard)

    def get_time_source(self, mboard: "size_t const") -> "std::string":
        r"""get_time_source(sink_sptr self, size_t const mboard) -> std::string"""
        return _osmosdr_swig.sink_sptr_get_time_source(self, mboard)

    def get_time_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_time_sources(sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_sptr_get_time_sources(self, mboard)

    def set_clock_source(self, source: "std::string const &", mboard: "size_t const"=0) -> "void":
        r"""set_clock_source(sink_sptr self, std::string const & source, size_t const mboard=0)"""
        return _osmosdr_swig.sink_sptr_set_clock_source(self, source, mboard)

    def get_clock_source(self, mboard: "size_t const") -> "std::string":
        r"""get_clock_source(sink_sptr self, size_t const mboard) -> std::string"""
        return _osmosdr_swig.sink_sptr_get_clock_source(self, mboard)

    def get_clock_sources(self, mboard: "size_t const") -> "std::vector< std::string,std::allocator< std::string > >":
        r"""get_clock_sources(sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_sptr_get_clock_sources(self, mboard)

    def get_clock_rate(self, mboard: "size_t"=0) -> "double":
        r"""get_clock_rate(sink_sptr self, size_t mboard=0) -> double"""
        return _osmosdr_swig.sink_sptr_get_clock_rate(self, mboard)

    def set_clock_rate(self, rate: "double", mboard: "size_t"=0) -> "void":
        r"""set_clock_rate(sink_sptr self, double rate, size_t mboard=0)"""
        return _osmosdr_swig.sink_sptr_set_clock_rate(self, rate, mboard)

    def get_time_now(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""get_time_now(sink_sptr self, size_t mboard=0) -> time_spec_t"""
        return _osmosdr_swig.sink_sptr_get_time_now(self, mboard)

    def get_time_last_pps(self, mboard: "size_t"=0) -> "::osmosdr::time_spec_t":
        r"""get_time_last_pps(sink_sptr self, size_t mboard=0) -> time_spec_t"""
        return _osmosdr_swig.sink_sptr_get_time_last_pps(self, mboard)

    def set_time_now(self, time_spec: "time_spec_t", mboard: "size_t"=0) -> "void":
        r"""set_time_now(sink_sptr self, time_spec_t time_spec, size_t mboard=0)"""
        return _osmosdr_swig.sink_sptr_set_time_now(self, time_spec, mboard)

    def set_time_next_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_next_pps(sink_sptr self, time_spec_t time_spec)"""
        return _osmosdr_swig.sink_sptr_set_time_next_pps(self, time_spec)

    def set_time_unknown_pps(self, time_spec: "time_spec_t") -> "void":
        r"""set_time_unknown_pps(sink_sptr self, time_spec_t time_spec)"""
        return _osmosdr_swig.sink_sptr_set_time_unknown_pps(self, time_spec)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(sink_sptr self, basic_block_sptr block)
        primitive_connect(sink_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.sink_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(sink_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(sink_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.sink_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(sink_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(sink_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.sink_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(sink_sptr self, basic_block_sptr block)
        primitive_disconnect(sink_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.sink_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(sink_sptr self, swig_pmt_ptr port_id)"""
        return _osmosdr_swig.sink_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(sink_sptr self, swig_pmt_ptr port_id)"""
        return _osmosdr_swig.sink_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _osmosdr_swig.sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _osmosdr_swig.sink_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sink_sptr self, std::string level)"""
        return _osmosdr_swig.sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(sink_sptr self, int i) -> size_t"""
        return _osmosdr_swig.sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(sink_sptr self, size_t max_output_buffer)
        set_max_output_buffer(sink_sptr self, int port, size_t max_output_buffer)
        """
        return _osmosdr_swig.sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(sink_sptr self, int i) -> size_t"""
        return _osmosdr_swig.sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(sink_sptr self, size_t min_output_buffer)
        set_min_output_buffer(sink_sptr self, int port, size_t min_output_buffer)
        """
        return _osmosdr_swig.sink_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(sink_sptr self) -> hier_block2_sptr"""
        return _osmosdr_swig.sink_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sink_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sink_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(sink_sptr self) -> long"""
        return _osmosdr_swig.sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(sink_sptr self) -> basic_block_sptr"""
        return _osmosdr_swig.sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _osmosdr_swig.sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(sink_sptr self, std::string name)"""
        return _osmosdr_swig.sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _osmosdr_swig.sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sink_sptr self) -> swig_pmt_ptr"""
        return _osmosdr_swig.sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sink_sptr self) -> swig_pmt_ptr"""
        return _osmosdr_swig.sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _osmosdr_swig.sink_sptr_message_subscribers(self, which_port)

# Register sink_sptr in _osmosdr_swig:
_osmosdr_swig.sink_sptr_swigregister(sink_sptr)


sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
sink = sink.make;



