# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.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
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _libdivvun
else:
    import _libdivvun

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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


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


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


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


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

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

    def value(self):
        return _libdivvun.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _libdivvun.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _libdivvun.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _libdivvun.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _libdivvun.SwigPyIterator_equal(self, x)

    def copy(self):
        return _libdivvun.SwigPyIterator_copy(self)

    def next(self):
        return _libdivvun.SwigPyIterator_next(self)

    def __next__(self):
        return _libdivvun.SwigPyIterator___next__(self)

    def previous(self):
        return _libdivvun.SwigPyIterator_previous(self)

    def advance(self, n):
        return _libdivvun.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _libdivvun.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _libdivvun.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _libdivvun.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _libdivvun.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _libdivvun.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _libdivvun.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _libdivvun:
_libdivvun.SwigPyIterator_swigregister(SwigPyIterator)
class CheckerUniquePtr(object):
    r"""Proxy of C++ std::unique_ptr< divvun::Checker > 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__(CheckerUniquePtr self, Checker Ptr) -> CheckerUniquePtr

        Parameters
        ----------
        Ptr: std::unique_ptr< divvun::Checker >::pointer

        __init__(CheckerUniquePtr self, CheckerUniquePtr Right) -> CheckerUniquePtr

        Parameters
        ----------
        Right: std::unique_ptr< divvun::Checker > &&

        """
        _libdivvun.CheckerUniquePtr_swiginit(self, _libdivvun.new_CheckerUniquePtr(*args))

    def __deref__(self):
        r"""__deref__(CheckerUniquePtr self) -> Checker"""
        return _libdivvun.CheckerUniquePtr___deref__(self)

    def release(self):
        r"""release(CheckerUniquePtr self) -> Checker"""
        return _libdivvun.CheckerUniquePtr_release(self)

    def reset(self, *args):
        r"""
        reset(CheckerUniquePtr self, Checker __p=std::unique_ptr< divvun::Checker >::pointer())

        Parameters
        ----------
        __p: std::unique_ptr< divvun::Checker >::pointer

        """
        return _libdivvun.CheckerUniquePtr_reset(self, *args)

    def swap(self, __u):
        r"""
        swap(CheckerUniquePtr self, CheckerUniquePtr __u)

        Parameters
        ----------
        __u: std::unique_ptr< divvun::Checker > &

        """
        return _libdivvun.CheckerUniquePtr_swap(self, __u)

    def get(self):
        r"""get(CheckerUniquePtr self) -> Checker"""
        return _libdivvun.CheckerUniquePtr_get(self)

    def __nonzero__(self):
        return _libdivvun.CheckerUniquePtr___nonzero__(self)
    __bool__ = __nonzero__


    __swig_destroy__ = _libdivvun.delete_CheckerUniquePtr

    def proc(self, input, output):
        r"""
        proc(CheckerUniquePtr self, std::stringstream & input, std::stringstream & output)

        Parameters
        ----------
        input: std::stringstream &
        output: std::stringstream &

        """
        return _libdivvun.CheckerUniquePtr_proc(self, input, output)

    def prefs(self):
        r"""prefs(CheckerUniquePtr self) -> divvun::LocalisedPrefs const &"""
        return _libdivvun.CheckerUniquePtr_prefs(self)

    def setIgnores(self, ignores):
        r"""
        setIgnores(CheckerUniquePtr self, std::set< divvun::ErrId,std::less< divvun::ErrId >,std::allocator< divvun::ErrId > > const & ignores)

        Parameters
        ----------
        ignores: std::set< divvun::ErrId,std::less< divvun::ErrId >,std::allocator< divvun::ErrId > > const &

        """
        return _libdivvun.CheckerUniquePtr_setIgnores(self, ignores)

# Register CheckerUniquePtr in _libdivvun:
_libdivvun.CheckerUniquePtr_swigregister(CheckerUniquePtr)
class Option(object):
    r"""Proxy of C++ divvun::Option class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libdivvun.Option_type_get, _libdivvun.Option_type_set, doc=r"""type : std::string""")
    name = property(_libdivvun.Option_name_get, _libdivvun.Option_name_set, doc=r"""name : std::string""")
    choices = property(_libdivvun.Option_choices_get, _libdivvun.Option_choices_set, doc=r"""choices : std::unordered_map<(divvun::ErrId,divvun::Msg)>""")

    def __init__(self):
        r"""__init__(Option self) -> Option"""
        _libdivvun.Option_swiginit(self, _libdivvun.new_Option())
    __swig_destroy__ = _libdivvun.delete_Option

# Register Option in _libdivvun:
_libdivvun.Option_swigregister(Option)
class OptionCompare(object):
    r"""Proxy of C++ divvun::OptionCompare class."""

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

    def __call__(self, a, b):
        r"""
        __call__(OptionCompare self, Option a, Option b) -> bool

        Parameters
        ----------
        a: divvun::Option const &
        b: divvun::Option const &

        """
        return _libdivvun.OptionCompare___call__(self, a, b)

    def __init__(self):
        r"""__init__(OptionCompare self) -> OptionCompare"""
        _libdivvun.OptionCompare_swiginit(self, _libdivvun.new_OptionCompare())
    __swig_destroy__ = _libdivvun.delete_OptionCompare

# Register OptionCompare in _libdivvun:
_libdivvun.OptionCompare_swigregister(OptionCompare)
class Prefs(object):
    r"""Proxy of C++ divvun::Prefs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    toggleIds = property(_libdivvun.Prefs_toggleIds_get, _libdivvun.Prefs_toggleIds_set, doc=r"""toggleIds : divvun::ToggleIds""")
    toggleRes = property(_libdivvun.Prefs_toggleRes_get, _libdivvun.Prefs_toggleRes_set, doc=r"""toggleRes : divvun::ToggleRes""")
    options = property(_libdivvun.Prefs_options_get, _libdivvun.Prefs_options_set, doc=r"""options : divvun::OptionSet""")

    def __init__(self):
        r"""__init__(Prefs self) -> Prefs"""
        _libdivvun.Prefs_swiginit(self, _libdivvun.new_Prefs())
    __swig_destroy__ = _libdivvun.delete_Prefs

# Register Prefs in _libdivvun:
_libdivvun.Prefs_swigregister(Prefs)
class CheckerSpec(object):
    r"""Proxy of C++ divvun::CheckerSpec 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, file):
        r"""
        __init__(CheckerSpec self, std::string const & file) -> CheckerSpec

        Parameters
        ----------
        file: std::string const &

        """
        _libdivvun.CheckerSpec_swiginit(self, _libdivvun.new_CheckerSpec(file))
    __swig_destroy__ = _libdivvun.delete_CheckerSpec

    def hasPipe(self, pipename):
        r"""
        hasPipe(CheckerSpec self, std::string const & pipename) -> bool

        Parameters
        ----------
        pipename: std::string const &

        """
        return _libdivvun.CheckerSpec_hasPipe(self, pipename)

    def defaultPipe(self):
        r"""defaultPipe(CheckerSpec self) -> std::string const"""
        return _libdivvun.CheckerSpec_defaultPipe(self)

    def pipeNames(self):
        r"""pipeNames(CheckerSpec self) -> StringSet"""
        return _libdivvun.CheckerSpec_pipeNames(self)

    def getChecker(self, pipename, verbose):
        r"""
        getChecker(CheckerSpec self, std::string const & pipename, bool verbose) -> CheckerUniquePtr

        Parameters
        ----------
        pipename: std::string const &
        verbose: bool

        """
        return _libdivvun.CheckerSpec_getChecker(self, pipename, verbose)

# Register CheckerSpec in _libdivvun:
_libdivvun.CheckerSpec_swigregister(CheckerSpec)
class ArCheckerSpec(object):
    r"""Proxy of C++ divvun::ArCheckerSpec 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, file):
        r"""
        __init__(ArCheckerSpec self, std::string const & file) -> ArCheckerSpec

        Parameters
        ----------
        file: std::string const &

        """
        _libdivvun.ArCheckerSpec_swiginit(self, _libdivvun.new_ArCheckerSpec(file))
    __swig_destroy__ = _libdivvun.delete_ArCheckerSpec

    def hasPipe(self, pipename):
        r"""
        hasPipe(ArCheckerSpec self, std::string const & pipename) -> bool

        Parameters
        ----------
        pipename: std::string const &

        """
        return _libdivvun.ArCheckerSpec_hasPipe(self, pipename)

    def defaultPipe(self):
        r"""defaultPipe(ArCheckerSpec self) -> std::string const"""
        return _libdivvun.ArCheckerSpec_defaultPipe(self)

    def pipeNames(self):
        r"""pipeNames(ArCheckerSpec self) -> StringSet"""
        return _libdivvun.ArCheckerSpec_pipeNames(self)

    def getChecker(self, pipename, verbose):
        r"""
        getChecker(ArCheckerSpec self, std::string const & pipename, bool verbose) -> CheckerUniquePtr

        Parameters
        ----------
        pipename: std::string const &
        verbose: bool

        """
        return _libdivvun.ArCheckerSpec_getChecker(self, pipename, verbose)

# Register ArCheckerSpec in _libdivvun:
_libdivvun.ArCheckerSpec_swigregister(ArCheckerSpec)
class Checker(object):
    r"""Proxy of C++ divvun::Checker 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__(Checker self, std::unique_ptr< divvun::PipeSpec > const & spec, std::string const & pipename, bool verbose) -> Checker

        Parameters
        ----------
        spec: std::unique_ptr< divvun::PipeSpec > const &
        pipename: std::string const &
        verbose: bool

        __init__(Checker self, std::unique_ptr< divvun::ArPipeSpec > const & spec, std::string const & pipename, bool verbose) -> Checker

        Parameters
        ----------
        spec: std::unique_ptr< divvun::ArPipeSpec > const &
        pipename: std::string const &
        verbose: bool

        """
        _libdivvun.Checker_swiginit(self, _libdivvun.new_Checker(*args))
    __swig_destroy__ = _libdivvun.delete_Checker

    def proc(self, input, output):
        r"""
        proc(Checker self, std::stringstream & input, std::stringstream & output)

        Parameters
        ----------
        input: std::stringstream &
        output: std::stringstream &

        """
        return _libdivvun.Checker_proc(self, input, output)

    def prefs(self):
        r"""prefs(Checker self) -> divvun::LocalisedPrefs const &"""
        return _libdivvun.Checker_prefs(self)

    def setIgnores(self, ignores):
        r"""
        setIgnores(Checker self, std::set< divvun::ErrId,std::less< divvun::ErrId >,std::allocator< divvun::ErrId > > const & ignores)

        Parameters
        ----------
        ignores: std::set< divvun::ErrId,std::less< divvun::ErrId >,std::allocator< divvun::ErrId > > const &

        """
        return _libdivvun.Checker_setIgnores(self, ignores)

# Register Checker in _libdivvun:
_libdivvun.Checker_swigregister(Checker)

def searchPaths():
    r"""searchPaths() -> StringSet"""
    return _libdivvun.searchPaths()

def listLangs(*args):
    r"""
    listLangs(std::string const & extraPath="") -> StringStringVectorMap

    Parameters
    ----------
    extraPath: std::string const &

    """
    return _libdivvun.listLangs(*args)
class StringVector(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):
        r"""iterator(StringVector self) -> SwigPyIterator"""
        return _libdivvun.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StringVector self) -> bool"""
        return _libdivvun.StringVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StringVector self) -> bool"""
        return _libdivvun.StringVector___bool__(self)

    def __len__(self):
        r"""__len__(StringVector self) -> std::vector< std::string >::size_type"""
        return _libdivvun.StringVector___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StringVector

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _libdivvun.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, StringVector v)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type
        v: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _libdivvun.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _libdivvun.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(StringVector self, std::vector< std::string >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        __delitem__(StringVector self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _libdivvun.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(StringVector self, SWIGPY_SLICEOBJECT * slice) -> StringVector

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(StringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        """
        return _libdivvun.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(StringVector self, SWIGPY_SLICEOBJECT * slice, StringVector v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::string,std::allocator< std::string > > const &

        __setitem__(StringVector self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        x: std::vector< std::string >::value_type const &

        """
        return _libdivvun.StringVector___setitem__(self, *args)

    def pop(self):
        r"""pop(StringVector self) -> std::vector< std::string >::value_type"""
        return _libdivvun.StringVector_pop(self)

    def append(self, x):
        r"""
        append(StringVector self, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _libdivvun.StringVector_append(self, x)

    def empty(self):
        r"""empty(StringVector self) -> bool"""
        return _libdivvun.StringVector_empty(self)

    def size(self):
        r"""size(StringVector self) -> std::vector< std::string >::size_type"""
        return _libdivvun.StringVector_size(self)

    def swap(self, v):
        r"""
        swap(StringVector self, StringVector v)

        Parameters
        ----------
        v: std::vector< std::string > &

        """
        return _libdivvun.StringVector_swap(self, v)

    def begin(self):
        r"""begin(StringVector self) -> std::vector< std::string >::iterator"""
        return _libdivvun.StringVector_begin(self)

    def end(self):
        r"""end(StringVector self) -> std::vector< std::string >::iterator"""
        return _libdivvun.StringVector_end(self)

    def rbegin(self):
        r"""rbegin(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _libdivvun.StringVector_rbegin(self)

    def rend(self):
        r"""rend(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _libdivvun.StringVector_rend(self)

    def clear(self):
        r"""clear(StringVector self)"""
        return _libdivvun.StringVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(StringVector self) -> std::vector< std::string >::allocator_type"""
        return _libdivvun.StringVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(StringVector self)"""
        return _libdivvun.StringVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(StringVector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator

        erase(StringVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator

        Parameters
        ----------
        first: std::vector< std::string >::iterator
        last: std::vector< std::string >::iterator

        """
        return _libdivvun.StringVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(StringVector self) -> StringVector
        __init__(StringVector self, StringVector other) -> StringVector

        Parameters
        ----------
        other: std::vector< std::string > const &

        __init__(StringVector self, std::vector< std::string >::size_type size) -> StringVector

        Parameters
        ----------
        size: std::vector< std::string >::size_type

        __init__(StringVector self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVector

        Parameters
        ----------
        size: std::vector< std::string >::size_type
        value: std::vector< std::string >::value_type const &

        """
        _libdivvun.StringVector_swiginit(self, _libdivvun.new_StringVector(*args))

    def push_back(self, x):
        r"""
        push_back(StringVector self, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _libdivvun.StringVector_push_back(self, x)

    def front(self):
        r"""front(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _libdivvun.StringVector_front(self)

    def back(self):
        r"""back(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _libdivvun.StringVector_back(self)

    def assign(self, n, x):
        r"""
        assign(StringVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _libdivvun.StringVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(StringVector self, std::vector< std::string >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type

        resize(StringVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _libdivvun.StringVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        x: std::vector< std::string >::value_type const &

        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _libdivvun.StringVector_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(StringVector self, std::vector< std::string >::size_type n)

        Parameters
        ----------
        n: std::vector< std::string >::size_type

        """
        return _libdivvun.StringVector_reserve(self, n)

    def capacity(self):
        r"""capacity(StringVector self) -> std::vector< std::string >::size_type"""
        return _libdivvun.StringVector_capacity(self)
    __swig_destroy__ = _libdivvun.delete_StringVector

# Register StringVector in _libdivvun:
_libdivvun.StringVector_swigregister(StringVector)
class StringSet(object):
    r"""Proxy of C++ std::set< 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):
        r"""iterator(StringSet self) -> SwigPyIterator"""
        return _libdivvun.StringSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StringSet self) -> bool"""
        return _libdivvun.StringSet___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StringSet self) -> bool"""
        return _libdivvun.StringSet___bool__(self)

    def __len__(self):
        r"""__len__(StringSet self) -> std::set< std::string >::size_type"""
        return _libdivvun.StringSet___len__(self)

    def append(self, x):
        r"""
        append(StringSet self, std::set< std::string >::value_type x)

        Parameters
        ----------
        x: std::set< std::string >::value_type

        """
        return _libdivvun.StringSet_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(StringSet self, std::set< std::string >::value_type x) -> bool

        Parameters
        ----------
        x: std::set< std::string >::value_type

        """
        return _libdivvun.StringSet___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(StringSet self, std::set< std::string >::difference_type i) -> std::set< std::string >::value_type

        Parameters
        ----------
        i: std::set< std::string >::difference_type

        """
        return _libdivvun.StringSet___getitem__(self, i)

    def add(self, x):
        r"""
        add(StringSet self, std::set< std::string >::value_type x)

        Parameters
        ----------
        x: std::set< std::string >::value_type

        """
        return _libdivvun.StringSet_add(self, x)

    def discard(self, x):
        r"""
        discard(StringSet self, std::set< std::string >::value_type x)

        Parameters
        ----------
        x: std::set< std::string >::value_type

        """
        return _libdivvun.StringSet_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(StringSet self, std::less< std::string > const & other) -> StringSet

        Parameters
        ----------
        other: std::less< std::string > const &

        __init__(StringSet self) -> StringSet
        __init__(StringSet self, StringSet other) -> StringSet

        Parameters
        ----------
        other: std::set< std::string > const &

        """
        _libdivvun.StringSet_swiginit(self, _libdivvun.new_StringSet(*args))

    def empty(self):
        r"""empty(StringSet self) -> bool"""
        return _libdivvun.StringSet_empty(self)

    def size(self):
        r"""size(StringSet self) -> std::set< std::string >::size_type"""
        return _libdivvun.StringSet_size(self)

    def clear(self):
        r"""clear(StringSet self)"""
        return _libdivvun.StringSet_clear(self)

    def swap(self, v):
        r"""
        swap(StringSet self, StringSet v)

        Parameters
        ----------
        v: std::set< std::string > &

        """
        return _libdivvun.StringSet_swap(self, v)

    def count(self, x):
        r"""
        count(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::size_type

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _libdivvun.StringSet_count(self, x)

    def begin(self):
        r"""begin(StringSet self) -> std::set< std::string >::iterator"""
        return _libdivvun.StringSet_begin(self)

    def end(self):
        r"""end(StringSet self) -> std::set< std::string >::iterator"""
        return _libdivvun.StringSet_end(self)

    def rbegin(self):
        r"""rbegin(StringSet self) -> std::set< std::string >::reverse_iterator"""
        return _libdivvun.StringSet_rbegin(self)

    def rend(self):
        r"""rend(StringSet self) -> std::set< std::string >::reverse_iterator"""
        return _libdivvun.StringSet_rend(self)

    def erase(self, *args):
        r"""
        erase(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::size_type

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        erase(StringSet self, std::set< std::string >::iterator pos)

        Parameters
        ----------
        pos: std::set< std::string >::iterator

        erase(StringSet self, std::set< std::string >::iterator first, std::set< std::string >::iterator last)

        Parameters
        ----------
        first: std::set< std::string >::iterator
        last: std::set< std::string >::iterator

        """
        return _libdivvun.StringSet_erase(self, *args)

    def find(self, x):
        r"""
        find(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _libdivvun.StringSet_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _libdivvun.StringSet_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _libdivvun.StringSet_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(StringSet self, std::set< std::string >::key_type const & x) -> std::pair< std::set< std::string >::iterator,std::set< std::string >::iterator >

        Parameters
        ----------
        x: std::set< std::string >::key_type const &

        """
        return _libdivvun.StringSet_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(StringSet self, std::set< std::string >::value_type const & __x) -> std::pair< std::set< std::string >::iterator,bool >

        Parameters
        ----------
        __x: std::set< std::string >::value_type const &

        """
        return _libdivvun.StringSet_insert(self, __x)
    __swig_destroy__ = _libdivvun.delete_StringSet

# Register StringSet in _libdivvun:
_libdivvun.StringSet_swigregister(StringSet)
class StringStringVectorMap(object):
    r"""Proxy of C++ std::map< std::string,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):
        r"""iterator(StringStringVectorMap self) -> SwigPyIterator"""
        return _libdivvun.StringStringVectorMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StringStringVectorMap self) -> bool"""
        return _libdivvun.StringStringVectorMap___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StringStringVectorMap self) -> bool"""
        return _libdivvun.StringStringVectorMap___bool__(self)

    def __len__(self):
        r"""__len__(StringStringVectorMap self) -> std::map< std::string,std::vector< std::string > >::size_type"""
        return _libdivvun.StringStringVectorMap___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):
        r"""
        __getitem__(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & key) -> StringVector

        Parameters
        ----------
        key: std::map< std::string,std::vector< std::string > >::key_type const &

        """
        return _libdivvun.StringStringVectorMap___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,std::vector< std::string > >::key_type const &

        """
        return _libdivvun.StringStringVectorMap___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,std::vector< std::string > >::key_type const &

        """
        return _libdivvun.StringStringVectorMap_has_key(self, key)

    def keys(self):
        r"""keys(StringStringVectorMap self) -> PyObject *"""
        return _libdivvun.StringStringVectorMap_keys(self)

    def values(self):
        r"""values(StringStringVectorMap self) -> PyObject *"""
        return _libdivvun.StringStringVectorMap_values(self)

    def items(self):
        r"""items(StringStringVectorMap self) -> PyObject *"""
        return _libdivvun.StringStringVectorMap_items(self)

    def __contains__(self, key):
        r"""
        __contains__(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,std::vector< std::string > >::key_type const &

        """
        return _libdivvun.StringStringVectorMap___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(StringStringVectorMap self) -> SwigPyIterator"""
        return _libdivvun.StringStringVectorMap_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(StringStringVectorMap self) -> SwigPyIterator"""
        return _libdivvun.StringStringVectorMap_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,std::vector< std::string > >::key_type const &

        __setitem__(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & key, StringVector x)

        Parameters
        ----------
        key: std::map< std::string,std::vector< std::string > >::key_type const &
        x: std::map< std::string,std::vector< std::string > >::mapped_type const &

        """
        return _libdivvun.StringStringVectorMap___setitem__(self, *args)

    def asdict(self):
        r"""asdict(StringStringVectorMap self) -> PyObject *"""
        return _libdivvun.StringStringVectorMap_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(StringStringVectorMap self, std::less< std::string > const & other) -> StringStringVectorMap

        Parameters
        ----------
        other: std::less< std::string > const &

        __init__(StringStringVectorMap self) -> StringStringVectorMap
        __init__(StringStringVectorMap self, StringStringVectorMap other) -> StringStringVectorMap

        Parameters
        ----------
        other: std::map< std::string,std::vector< std::string,std::allocator< std::string > > > const &

        """
        _libdivvun.StringStringVectorMap_swiginit(self, _libdivvun.new_StringStringVectorMap(*args))

    def empty(self):
        r"""empty(StringStringVectorMap self) -> bool"""
        return _libdivvun.StringStringVectorMap_empty(self)

    def size(self):
        r"""size(StringStringVectorMap self) -> std::map< std::string,std::vector< std::string > >::size_type"""
        return _libdivvun.StringStringVectorMap_size(self)

    def swap(self, v):
        r"""
        swap(StringStringVectorMap self, StringStringVectorMap v)

        Parameters
        ----------
        v: std::map< std::string,std::vector< std::string,std::allocator< std::string > > > &

        """
        return _libdivvun.StringStringVectorMap_swap(self, v)

    def begin(self):
        r"""begin(StringStringVectorMap self) -> std::map< std::string,std::vector< std::string > >::iterator"""
        return _libdivvun.StringStringVectorMap_begin(self)

    def end(self):
        r"""end(StringStringVectorMap self) -> std::map< std::string,std::vector< std::string > >::iterator"""
        return _libdivvun.StringStringVectorMap_end(self)

    def rbegin(self):
        r"""rbegin(StringStringVectorMap self) -> std::map< std::string,std::vector< std::string > >::reverse_iterator"""
        return _libdivvun.StringStringVectorMap_rbegin(self)

    def rend(self):
        r"""rend(StringStringVectorMap self) -> std::map< std::string,std::vector< std::string > >::reverse_iterator"""
        return _libdivvun.StringStringVectorMap_rend(self)

    def clear(self):
        r"""clear(StringStringVectorMap self)"""
        return _libdivvun.StringStringVectorMap_clear(self)

    def get_allocator(self):
        r"""get_allocator(StringStringVectorMap self) -> std::map< std::string,std::vector< std::string > >::allocator_type"""
        return _libdivvun.StringStringVectorMap_get_allocator(self)

    def count(self, x):
        r"""
        count(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & x) -> std::map< std::string,std::vector< std::string > >::size_type

        Parameters
        ----------
        x: std::map< std::string,std::vector< std::string > >::key_type const &

        """
        return _libdivvun.StringStringVectorMap_count(self, x)

    def erase(self, *args):
        r"""
        erase(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & x) -> std::map< std::string,std::vector< std::string > >::size_type

        Parameters
        ----------
        x: std::map< std::string,std::vector< std::string > >::key_type const &

        erase(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::iterator position)

        Parameters
        ----------
        position: std::map< std::string,std::vector< std::string > >::iterator

        erase(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::iterator first, std::map< std::string,std::vector< std::string > >::iterator last)

        Parameters
        ----------
        first: std::map< std::string,std::vector< std::string > >::iterator
        last: std::map< std::string,std::vector< std::string > >::iterator

        """
        return _libdivvun.StringStringVectorMap_erase(self, *args)

    def find(self, x):
        r"""
        find(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & x) -> std::map< std::string,std::vector< std::string > >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::vector< std::string > >::key_type const &

        """
        return _libdivvun.StringStringVectorMap_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & x) -> std::map< std::string,std::vector< std::string > >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::vector< std::string > >::key_type const &

        """
        return _libdivvun.StringStringVectorMap_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(StringStringVectorMap self, std::map< std::string,std::vector< std::string > >::key_type const & x) -> std::map< std::string,std::vector< std::string > >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::vector< std::string > >::key_type const &

        """
        return _libdivvun.StringStringVectorMap_upper_bound(self, x)
    __swig_destroy__ = _libdivvun.delete_StringStringVectorMap

# Register StringStringVectorMap in _libdivvun:
_libdivvun.StringStringVectorMap_swigregister(StringStringVectorMap)
class ErrBytes(object):
    r"""Proxy of C++ ErrBytes class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    form = property(_libdivvun.ErrBytes_form_get, _libdivvun.ErrBytes_form_set, doc=r"""form : std::string""")
    beg = property(_libdivvun.ErrBytes_beg_get, _libdivvun.ErrBytes_beg_set, doc=r"""beg : size_t""")
    end = property(_libdivvun.ErrBytes_end_get, _libdivvun.ErrBytes_end_set, doc=r"""end : size_t""")
    err = property(_libdivvun.ErrBytes_err_get, _libdivvun.ErrBytes_err_set, doc=r"""err : std::string""")
    dsc = property(_libdivvun.ErrBytes_dsc_get, _libdivvun.ErrBytes_dsc_set, doc=r"""dsc : std::string""")
    rep = property(_libdivvun.ErrBytes_rep_get, _libdivvun.ErrBytes_rep_set, doc=r"""rep : StringVector""")
    msg = property(_libdivvun.ErrBytes_msg_get, _libdivvun.ErrBytes_msg_set, doc=r"""msg : std::string""")

    def __init__(self):
        r"""__init__(ErrBytes self) -> ErrBytes"""
        _libdivvun.ErrBytes_swiginit(self, _libdivvun.new_ErrBytes())
    __swig_destroy__ = _libdivvun.delete_ErrBytes

# Register ErrBytes in _libdivvun:
_libdivvun.ErrBytes_swigregister(ErrBytes)
class OptionBytes(object):
    r"""Proxy of C++ OptionBytes class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libdivvun.OptionBytes_type_get, _libdivvun.OptionBytes_type_set, doc=r"""type : std::string""")
    name = property(_libdivvun.OptionBytes_name_get, _libdivvun.OptionBytes_name_set, doc=r"""name : std::string""")
    choices = property(_libdivvun.OptionBytes_choices_get, _libdivvun.OptionBytes_choices_set, doc=r"""choices : ToggleIdsBytes""")

    def __init__(self):
        r"""__init__(OptionBytes self) -> OptionBytes"""
        _libdivvun.OptionBytes_swiginit(self, _libdivvun.new_OptionBytes())
    __swig_destroy__ = _libdivvun.delete_OptionBytes

# Register OptionBytes in _libdivvun:
_libdivvun.OptionBytes_swigregister(OptionBytes)
class OptionBytesCompare(object):
    r"""Proxy of C++ OptionBytesCompare class."""

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

    def __call__(self, a, b):
        r"""
        __call__(OptionBytesCompare self, OptionBytes a, OptionBytes b) -> bool

        Parameters
        ----------
        a: OptionBytes const &
        b: OptionBytes const &

        """
        return _libdivvun.OptionBytesCompare___call__(self, a, b)

    def __init__(self):
        r"""__init__(OptionBytesCompare self) -> OptionBytesCompare"""
        _libdivvun.OptionBytesCompare_swiginit(self, _libdivvun.new_OptionBytesCompare())
    __swig_destroy__ = _libdivvun.delete_OptionBytesCompare

# Register OptionBytesCompare in _libdivvun:
_libdivvun.OptionBytesCompare_swigregister(OptionBytesCompare)
class PrefsBytes(object):
    r"""Proxy of C++ PrefsBytes class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    toggleIds = property(_libdivvun.PrefsBytes_toggleIds_get, _libdivvun.PrefsBytes_toggleIds_set, doc=r"""toggleIds : ToggleIdsBytes""")
    toggleRes = property(_libdivvun.PrefsBytes_toggleRes_get, _libdivvun.PrefsBytes_toggleRes_set, doc=r"""toggleRes : ToggleResBytes""")
    options = property(_libdivvun.PrefsBytes_options_get, _libdivvun.PrefsBytes_options_set, doc=r"""options : OptionSetBytes""")

    def __init__(self):
        r"""__init__(PrefsBytes self) -> PrefsBytes"""
        _libdivvun.PrefsBytes_swiginit(self, _libdivvun.new_PrefsBytes())
    __swig_destroy__ = _libdivvun.delete_PrefsBytes

# Register PrefsBytes in _libdivvun:
_libdivvun.PrefsBytes_swigregister(PrefsBytes)
class ErrBytesVector(object):
    r"""Proxy of C++ std::vector< ErrBytes > class."""

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

    def iterator(self):
        r"""iterator(ErrBytesVector self) -> SwigPyIterator"""
        return _libdivvun.ErrBytesVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ErrBytesVector self) -> bool"""
        return _libdivvun.ErrBytesVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ErrBytesVector self) -> bool"""
        return _libdivvun.ErrBytesVector___bool__(self)

    def __len__(self):
        r"""__len__(ErrBytesVector self) -> std::vector< ErrBytes >::size_type"""
        return _libdivvun.ErrBytesVector___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(ErrBytesVector self, std::vector< ErrBytes >::difference_type i, std::vector< ErrBytes >::difference_type j) -> ErrBytesVector

        Parameters
        ----------
        i: std::vector< ErrBytes >::difference_type
        j: std::vector< ErrBytes >::difference_type

        """
        return _libdivvun.ErrBytesVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(ErrBytesVector self, std::vector< ErrBytes >::difference_type i, std::vector< ErrBytes >::difference_type j)

        Parameters
        ----------
        i: std::vector< ErrBytes >::difference_type
        j: std::vector< ErrBytes >::difference_type

        __setslice__(ErrBytesVector self, std::vector< ErrBytes >::difference_type i, std::vector< ErrBytes >::difference_type j, ErrBytesVector v)

        Parameters
        ----------
        i: std::vector< ErrBytes >::difference_type
        j: std::vector< ErrBytes >::difference_type
        v: std::vector< ErrBytes,std::allocator< ErrBytes > > const &

        """
        return _libdivvun.ErrBytesVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(ErrBytesVector self, std::vector< ErrBytes >::difference_type i, std::vector< ErrBytes >::difference_type j)

        Parameters
        ----------
        i: std::vector< ErrBytes >::difference_type
        j: std::vector< ErrBytes >::difference_type

        """
        return _libdivvun.ErrBytesVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(ErrBytesVector self, std::vector< ErrBytes >::difference_type i)

        Parameters
        ----------
        i: std::vector< ErrBytes >::difference_type

        __delitem__(ErrBytesVector self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _libdivvun.ErrBytesVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(ErrBytesVector self, SWIGPY_SLICEOBJECT * slice) -> ErrBytesVector

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(ErrBytesVector self, std::vector< ErrBytes >::difference_type i) -> ErrBytes

        Parameters
        ----------
        i: std::vector< ErrBytes >::difference_type

        """
        return _libdivvun.ErrBytesVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(ErrBytesVector self, SWIGPY_SLICEOBJECT * slice, ErrBytesVector v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< ErrBytes,std::allocator< ErrBytes > > const &

        __setitem__(ErrBytesVector self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(ErrBytesVector self, std::vector< ErrBytes >::difference_type i, ErrBytes x)

        Parameters
        ----------
        i: std::vector< ErrBytes >::difference_type
        x: std::vector< ErrBytes >::value_type const &

        """
        return _libdivvun.ErrBytesVector___setitem__(self, *args)

    def pop(self):
        r"""pop(ErrBytesVector self) -> ErrBytes"""
        return _libdivvun.ErrBytesVector_pop(self)

    def append(self, x):
        r"""
        append(ErrBytesVector self, ErrBytes x)

        Parameters
        ----------
        x: std::vector< ErrBytes >::value_type const &

        """
        return _libdivvun.ErrBytesVector_append(self, x)

    def empty(self):
        r"""empty(ErrBytesVector self) -> bool"""
        return _libdivvun.ErrBytesVector_empty(self)

    def size(self):
        r"""size(ErrBytesVector self) -> std::vector< ErrBytes >::size_type"""
        return _libdivvun.ErrBytesVector_size(self)

    def swap(self, v):
        r"""
        swap(ErrBytesVector self, ErrBytesVector v)

        Parameters
        ----------
        v: std::vector< ErrBytes > &

        """
        return _libdivvun.ErrBytesVector_swap(self, v)

    def begin(self):
        r"""begin(ErrBytesVector self) -> std::vector< ErrBytes >::iterator"""
        return _libdivvun.ErrBytesVector_begin(self)

    def end(self):
        r"""end(ErrBytesVector self) -> std::vector< ErrBytes >::iterator"""
        return _libdivvun.ErrBytesVector_end(self)

    def rbegin(self):
        r"""rbegin(ErrBytesVector self) -> std::vector< ErrBytes >::reverse_iterator"""
        return _libdivvun.ErrBytesVector_rbegin(self)

    def rend(self):
        r"""rend(ErrBytesVector self) -> std::vector< ErrBytes >::reverse_iterator"""
        return _libdivvun.ErrBytesVector_rend(self)

    def clear(self):
        r"""clear(ErrBytesVector self)"""
        return _libdivvun.ErrBytesVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(ErrBytesVector self) -> std::vector< ErrBytes >::allocator_type"""
        return _libdivvun.ErrBytesVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(ErrBytesVector self)"""
        return _libdivvun.ErrBytesVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(ErrBytesVector self, std::vector< ErrBytes >::iterator pos) -> std::vector< ErrBytes >::iterator

        Parameters
        ----------
        pos: std::vector< ErrBytes >::iterator

        erase(ErrBytesVector self, std::vector< ErrBytes >::iterator first, std::vector< ErrBytes >::iterator last) -> std::vector< ErrBytes >::iterator

        Parameters
        ----------
        first: std::vector< ErrBytes >::iterator
        last: std::vector< ErrBytes >::iterator

        """
        return _libdivvun.ErrBytesVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ErrBytesVector self) -> ErrBytesVector
        __init__(ErrBytesVector self, ErrBytesVector other) -> ErrBytesVector

        Parameters
        ----------
        other: std::vector< ErrBytes > const &

        __init__(ErrBytesVector self, std::vector< ErrBytes >::size_type size) -> ErrBytesVector

        Parameters
        ----------
        size: std::vector< ErrBytes >::size_type

        __init__(ErrBytesVector self, std::vector< ErrBytes >::size_type size, ErrBytes value) -> ErrBytesVector

        Parameters
        ----------
        size: std::vector< ErrBytes >::size_type
        value: std::vector< ErrBytes >::value_type const &

        """
        _libdivvun.ErrBytesVector_swiginit(self, _libdivvun.new_ErrBytesVector(*args))

    def push_back(self, x):
        r"""
        push_back(ErrBytesVector self, ErrBytes x)

        Parameters
        ----------
        x: std::vector< ErrBytes >::value_type const &

        """
        return _libdivvun.ErrBytesVector_push_back(self, x)

    def front(self):
        r"""front(ErrBytesVector self) -> ErrBytes"""
        return _libdivvun.ErrBytesVector_front(self)

    def back(self):
        r"""back(ErrBytesVector self) -> ErrBytes"""
        return _libdivvun.ErrBytesVector_back(self)

    def assign(self, n, x):
        r"""
        assign(ErrBytesVector self, std::vector< ErrBytes >::size_type n, ErrBytes x)

        Parameters
        ----------
        n: std::vector< ErrBytes >::size_type
        x: std::vector< ErrBytes >::value_type const &

        """
        return _libdivvun.ErrBytesVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(ErrBytesVector self, std::vector< ErrBytes >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< ErrBytes >::size_type

        resize(ErrBytesVector self, std::vector< ErrBytes >::size_type new_size, ErrBytes x)

        Parameters
        ----------
        new_size: std::vector< ErrBytes >::size_type
        x: std::vector< ErrBytes >::value_type const &

        """
        return _libdivvun.ErrBytesVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(ErrBytesVector self, std::vector< ErrBytes >::iterator pos, ErrBytes x) -> std::vector< ErrBytes >::iterator

        Parameters
        ----------
        pos: std::vector< ErrBytes >::iterator
        x: std::vector< ErrBytes >::value_type const &

        insert(ErrBytesVector self, std::vector< ErrBytes >::iterator pos, std::vector< ErrBytes >::size_type n, ErrBytes x)

        Parameters
        ----------
        pos: std::vector< ErrBytes >::iterator
        n: std::vector< ErrBytes >::size_type
        x: std::vector< ErrBytes >::value_type const &

        """
        return _libdivvun.ErrBytesVector_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(ErrBytesVector self, std::vector< ErrBytes >::size_type n)

        Parameters
        ----------
        n: std::vector< ErrBytes >::size_type

        """
        return _libdivvun.ErrBytesVector_reserve(self, n)

    def capacity(self):
        r"""capacity(ErrBytesVector self) -> std::vector< ErrBytes >::size_type"""
        return _libdivvun.ErrBytesVector_capacity(self)
    __swig_destroy__ = _libdivvun.delete_ErrBytesVector

# Register ErrBytesVector in _libdivvun:
_libdivvun.ErrBytesVector_swigregister(ErrBytesVector)
class ToggleIdsBytes(object):
    r"""Proxy of C++ std::map< std::string,std::pair< 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):
        r"""iterator(ToggleIdsBytes self) -> SwigPyIterator"""
        return _libdivvun.ToggleIdsBytes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ToggleIdsBytes self) -> bool"""
        return _libdivvun.ToggleIdsBytes___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ToggleIdsBytes self) -> bool"""
        return _libdivvun.ToggleIdsBytes___bool__(self)

    def __len__(self):
        r"""__len__(ToggleIdsBytes self) -> std::map< std::string,std::pair< std::string,std::string > >::size_type"""
        return _libdivvun.ToggleIdsBytes___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):
        r"""
        __getitem__(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & key) -> std::map< std::string,std::pair< std::string,std::string > >::mapped_type const &

        Parameters
        ----------
        key: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        """
        return _libdivvun.ToggleIdsBytes___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        """
        return _libdivvun.ToggleIdsBytes___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        """
        return _libdivvun.ToggleIdsBytes_has_key(self, key)

    def keys(self):
        r"""keys(ToggleIdsBytes self) -> PyObject *"""
        return _libdivvun.ToggleIdsBytes_keys(self)

    def values(self):
        r"""values(ToggleIdsBytes self) -> PyObject *"""
        return _libdivvun.ToggleIdsBytes_values(self)

    def items(self):
        r"""items(ToggleIdsBytes self) -> PyObject *"""
        return _libdivvun.ToggleIdsBytes_items(self)

    def __contains__(self, key):
        r"""
        __contains__(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        """
        return _libdivvun.ToggleIdsBytes___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(ToggleIdsBytes self) -> SwigPyIterator"""
        return _libdivvun.ToggleIdsBytes_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(ToggleIdsBytes self) -> SwigPyIterator"""
        return _libdivvun.ToggleIdsBytes_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        __setitem__(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & key, std::map< std::string,std::pair< std::string,std::string > >::mapped_type const & x)

        Parameters
        ----------
        key: std::map< std::string,std::pair< std::string,std::string > >::key_type const &
        x: std::map< std::string,std::pair< std::string,std::string > >::mapped_type const &

        """
        return _libdivvun.ToggleIdsBytes___setitem__(self, *args)

    def asdict(self):
        r"""asdict(ToggleIdsBytes self) -> PyObject *"""
        return _libdivvun.ToggleIdsBytes_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(ToggleIdsBytes self, std::less< std::string > const & other) -> ToggleIdsBytes

        Parameters
        ----------
        other: std::less< std::string > const &

        __init__(ToggleIdsBytes self) -> ToggleIdsBytes
        __init__(ToggleIdsBytes self, ToggleIdsBytes other) -> ToggleIdsBytes

        Parameters
        ----------
        other: std::map< std::string,std::pair< std::string,std::string > > const &

        """
        _libdivvun.ToggleIdsBytes_swiginit(self, _libdivvun.new_ToggleIdsBytes(*args))

    def empty(self):
        r"""empty(ToggleIdsBytes self) -> bool"""
        return _libdivvun.ToggleIdsBytes_empty(self)

    def size(self):
        r"""size(ToggleIdsBytes self) -> std::map< std::string,std::pair< std::string,std::string > >::size_type"""
        return _libdivvun.ToggleIdsBytes_size(self)

    def swap(self, v):
        r"""
        swap(ToggleIdsBytes self, ToggleIdsBytes v)

        Parameters
        ----------
        v: std::map< std::string,std::pair< std::string,std::string > > &

        """
        return _libdivvun.ToggleIdsBytes_swap(self, v)

    def begin(self):
        r"""begin(ToggleIdsBytes self) -> std::map< std::string,std::pair< std::string,std::string > >::iterator"""
        return _libdivvun.ToggleIdsBytes_begin(self)

    def end(self):
        r"""end(ToggleIdsBytes self) -> std::map< std::string,std::pair< std::string,std::string > >::iterator"""
        return _libdivvun.ToggleIdsBytes_end(self)

    def rbegin(self):
        r"""rbegin(ToggleIdsBytes self) -> std::map< std::string,std::pair< std::string,std::string > >::reverse_iterator"""
        return _libdivvun.ToggleIdsBytes_rbegin(self)

    def rend(self):
        r"""rend(ToggleIdsBytes self) -> std::map< std::string,std::pair< std::string,std::string > >::reverse_iterator"""
        return _libdivvun.ToggleIdsBytes_rend(self)

    def clear(self):
        r"""clear(ToggleIdsBytes self)"""
        return _libdivvun.ToggleIdsBytes_clear(self)

    def get_allocator(self):
        r"""get_allocator(ToggleIdsBytes self) -> std::map< std::string,std::pair< std::string,std::string > >::allocator_type"""
        return _libdivvun.ToggleIdsBytes_get_allocator(self)

    def count(self, x):
        r"""
        count(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & x) -> std::map< std::string,std::pair< std::string,std::string > >::size_type

        Parameters
        ----------
        x: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        """
        return _libdivvun.ToggleIdsBytes_count(self, x)

    def erase(self, *args):
        r"""
        erase(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & x) -> std::map< std::string,std::pair< std::string,std::string > >::size_type

        Parameters
        ----------
        x: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        erase(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::iterator position)

        Parameters
        ----------
        position: std::map< std::string,std::pair< std::string,std::string > >::iterator

        erase(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::iterator first, std::map< std::string,std::pair< std::string,std::string > >::iterator last)

        Parameters
        ----------
        first: std::map< std::string,std::pair< std::string,std::string > >::iterator
        last: std::map< std::string,std::pair< std::string,std::string > >::iterator

        """
        return _libdivvun.ToggleIdsBytes_erase(self, *args)

    def find(self, x):
        r"""
        find(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & x) -> std::map< std::string,std::pair< std::string,std::string > >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        """
        return _libdivvun.ToggleIdsBytes_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & x) -> std::map< std::string,std::pair< std::string,std::string > >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        """
        return _libdivvun.ToggleIdsBytes_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(ToggleIdsBytes self, std::map< std::string,std::pair< std::string,std::string > >::key_type const & x) -> std::map< std::string,std::pair< std::string,std::string > >::iterator

        Parameters
        ----------
        x: std::map< std::string,std::pair< std::string,std::string > >::key_type const &

        """
        return _libdivvun.ToggleIdsBytes_upper_bound(self, x)
    __swig_destroy__ = _libdivvun.delete_ToggleIdsBytes

# Register ToggleIdsBytes in _libdivvun:
_libdivvun.ToggleIdsBytes_swigregister(ToggleIdsBytes)
class ToggleResBytes(object):
    r"""Proxy of C++ std::vector< std::pair< std::string,std::pair< 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):
        r"""iterator(ToggleResBytes self) -> SwigPyIterator"""
        return _libdivvun.ToggleResBytes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ToggleResBytes self) -> bool"""
        return _libdivvun.ToggleResBytes___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ToggleResBytes self) -> bool"""
        return _libdivvun.ToggleResBytes___bool__(self)

    def __len__(self):
        r"""__len__(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type"""
        return _libdivvun.ToggleResBytes___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type i, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type j) -> ToggleResBytes

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type
        j: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type

        """
        return _libdivvun.ToggleResBytes___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type i, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type
        j: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type

        __setslice__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type i, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type j, ToggleResBytes v)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type
        j: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type
        v: std::vector< std::pair< std::string,std::pair< std::string,std::string > >,std::allocator< std::pair< std::string,std::pair< std::string,std::string > > > > const &

        """
        return _libdivvun.ToggleResBytes___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type i, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type
        j: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type

        """
        return _libdivvun.ToggleResBytes___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type

        __delitem__(ToggleResBytes self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _libdivvun.ToggleResBytes___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(ToggleResBytes self, SWIGPY_SLICEOBJECT * slice) -> ToggleResBytes

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type i) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type

        """
        return _libdivvun.ToggleResBytes___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(ToggleResBytes self, SWIGPY_SLICEOBJECT * slice, ToggleResBytes v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::pair< std::string,std::pair< std::string,std::string > >,std::allocator< std::pair< std::string,std::pair< std::string,std::string > > > > const &

        __setitem__(ToggleResBytes self, SWIGPY_SLICEOBJECT * slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type i, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const & x)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::difference_type
        x: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        """
        return _libdivvun.ToggleResBytes___setitem__(self, *args)

    def pop(self):
        r"""pop(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type"""
        return _libdivvun.ToggleResBytes_pop(self)

    def append(self, x):
        r"""
        append(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        """
        return _libdivvun.ToggleResBytes_append(self, x)

    def empty(self):
        r"""empty(ToggleResBytes self) -> bool"""
        return _libdivvun.ToggleResBytes_empty(self)

    def size(self):
        r"""size(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type"""
        return _libdivvun.ToggleResBytes_size(self)

    def swap(self, v):
        r"""
        swap(ToggleResBytes self, ToggleResBytes v)

        Parameters
        ----------
        v: std::vector< std::pair< std::string,std::pair< std::string,std::string > > > &

        """
        return _libdivvun.ToggleResBytes_swap(self, v)

    def begin(self):
        r"""begin(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator"""
        return _libdivvun.ToggleResBytes_begin(self)

    def end(self):
        r"""end(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator"""
        return _libdivvun.ToggleResBytes_end(self)

    def rbegin(self):
        r"""rbegin(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::reverse_iterator"""
        return _libdivvun.ToggleResBytes_rbegin(self)

    def rend(self):
        r"""rend(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::reverse_iterator"""
        return _libdivvun.ToggleResBytes_rend(self)

    def clear(self):
        r"""clear(ToggleResBytes self)"""
        return _libdivvun.ToggleResBytes_clear(self)

    def get_allocator(self):
        r"""get_allocator(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::allocator_type"""
        return _libdivvun.ToggleResBytes_get_allocator(self)

    def pop_back(self):
        r"""pop_back(ToggleResBytes self)"""
        return _libdivvun.ToggleResBytes_pop_back(self)

    def erase(self, *args):
        r"""
        erase(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator pos) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator

        erase(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator first, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator last) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator

        Parameters
        ----------
        first: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator
        last: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator

        """
        return _libdivvun.ToggleResBytes_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ToggleResBytes self) -> ToggleResBytes
        __init__(ToggleResBytes self, ToggleResBytes other) -> ToggleResBytes

        Parameters
        ----------
        other: std::vector< std::pair< std::string,std::pair< std::string,std::string > > > const &

        __init__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type size) -> ToggleResBytes

        Parameters
        ----------
        size: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type

        __init__(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type size, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const & value) -> ToggleResBytes

        Parameters
        ----------
        size: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type
        value: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        """
        _libdivvun.ToggleResBytes_swiginit(self, _libdivvun.new_ToggleResBytes(*args))

    def push_back(self, x):
        r"""
        push_back(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        """
        return _libdivvun.ToggleResBytes_push_back(self, x)

    def front(self):
        r"""front(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &"""
        return _libdivvun.ToggleResBytes_front(self)

    def back(self):
        r"""back(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &"""
        return _libdivvun.ToggleResBytes_back(self)

    def assign(self, n, x):
        r"""
        assign(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type n, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const & x)

        Parameters
        ----------
        n: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type
        x: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        """
        return _libdivvun.ToggleResBytes_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type

        resize(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type new_size, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type
        x: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        """
        return _libdivvun.ToggleResBytes_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator pos, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const & x) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator
        x: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        insert(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator pos, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type n, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::iterator
        n: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type
        x: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::value_type const &

        """
        return _libdivvun.ToggleResBytes_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(ToggleResBytes self, std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type n)

        Parameters
        ----------
        n: std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type

        """
        return _libdivvun.ToggleResBytes_reserve(self, n)

    def capacity(self):
        r"""capacity(ToggleResBytes self) -> std::vector< std::pair< std::string,std::pair< std::string,std::string > > >::size_type"""
        return _libdivvun.ToggleResBytes_capacity(self)
    __swig_destroy__ = _libdivvun.delete_ToggleResBytes

# Register ToggleResBytes in _libdivvun:
_libdivvun.ToggleResBytes_swigregister(ToggleResBytes)
class OptionSetBytes(object):
    r"""Proxy of C++ std::set< OptionBytes,OptionBytesCompare > class."""

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

    def iterator(self):
        r"""iterator(OptionSetBytes self) -> SwigPyIterator"""
        return _libdivvun.OptionSetBytes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(OptionSetBytes self) -> bool"""
        return _libdivvun.OptionSetBytes___nonzero__(self)

    def __bool__(self):
        r"""__bool__(OptionSetBytes self) -> bool"""
        return _libdivvun.OptionSetBytes___bool__(self)

    def __len__(self):
        r"""__len__(OptionSetBytes self) -> std::set< OptionBytes,OptionBytesCompare >::size_type"""
        return _libdivvun.OptionSetBytes___len__(self)

    def append(self, x):
        r"""
        append(OptionSetBytes self, OptionBytes x)

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::value_type

        """
        return _libdivvun.OptionSetBytes_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(OptionSetBytes self, OptionBytes x) -> bool

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::value_type

        """
        return _libdivvun.OptionSetBytes___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(OptionSetBytes self, std::set< OptionBytes,OptionBytesCompare >::difference_type i) -> OptionBytes

        Parameters
        ----------
        i: std::set< OptionBytes,OptionBytesCompare >::difference_type

        """
        return _libdivvun.OptionSetBytes___getitem__(self, i)

    def add(self, x):
        r"""
        add(OptionSetBytes self, OptionBytes x)

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::value_type

        """
        return _libdivvun.OptionSetBytes_add(self, x)

    def discard(self, x):
        r"""
        discard(OptionSetBytes self, OptionBytes x)

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::value_type

        """
        return _libdivvun.OptionSetBytes_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(OptionSetBytes self, OptionBytesCompare other) -> OptionSetBytes

        Parameters
        ----------
        other: OptionBytesCompare const &

        __init__(OptionSetBytes self) -> OptionSetBytes
        __init__(OptionSetBytes self, OptionSetBytes other) -> OptionSetBytes

        Parameters
        ----------
        other: std::set< OptionBytes,OptionBytesCompare > const &

        """
        _libdivvun.OptionSetBytes_swiginit(self, _libdivvun.new_OptionSetBytes(*args))

    def empty(self):
        r"""empty(OptionSetBytes self) -> bool"""
        return _libdivvun.OptionSetBytes_empty(self)

    def size(self):
        r"""size(OptionSetBytes self) -> std::set< OptionBytes,OptionBytesCompare >::size_type"""
        return _libdivvun.OptionSetBytes_size(self)

    def clear(self):
        r"""clear(OptionSetBytes self)"""
        return _libdivvun.OptionSetBytes_clear(self)

    def swap(self, v):
        r"""
        swap(OptionSetBytes self, OptionSetBytes v)

        Parameters
        ----------
        v: std::set< OptionBytes,OptionBytesCompare > &

        """
        return _libdivvun.OptionSetBytes_swap(self, v)

    def count(self, x):
        r"""
        count(OptionSetBytes self, OptionBytes x) -> std::set< OptionBytes,OptionBytesCompare >::size_type

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::key_type const &

        """
        return _libdivvun.OptionSetBytes_count(self, x)

    def begin(self):
        r"""begin(OptionSetBytes self) -> std::set< OptionBytes,OptionBytesCompare >::iterator"""
        return _libdivvun.OptionSetBytes_begin(self)

    def end(self):
        r"""end(OptionSetBytes self) -> std::set< OptionBytes,OptionBytesCompare >::iterator"""
        return _libdivvun.OptionSetBytes_end(self)

    def rbegin(self):
        r"""rbegin(OptionSetBytes self) -> std::set< OptionBytes,OptionBytesCompare >::reverse_iterator"""
        return _libdivvun.OptionSetBytes_rbegin(self)

    def rend(self):
        r"""rend(OptionSetBytes self) -> std::set< OptionBytes,OptionBytesCompare >::reverse_iterator"""
        return _libdivvun.OptionSetBytes_rend(self)

    def erase(self, *args):
        r"""
        erase(OptionSetBytes self, OptionBytes x) -> std::set< OptionBytes,OptionBytesCompare >::size_type

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::key_type const &

        erase(OptionSetBytes self, std::set< OptionBytes,OptionBytesCompare >::iterator pos)

        Parameters
        ----------
        pos: std::set< OptionBytes,OptionBytesCompare >::iterator

        erase(OptionSetBytes self, std::set< OptionBytes,OptionBytesCompare >::iterator first, std::set< OptionBytes,OptionBytesCompare >::iterator last)

        Parameters
        ----------
        first: std::set< OptionBytes,OptionBytesCompare >::iterator
        last: std::set< OptionBytes,OptionBytesCompare >::iterator

        """
        return _libdivvun.OptionSetBytes_erase(self, *args)

    def find(self, x):
        r"""
        find(OptionSetBytes self, OptionBytes x) -> std::set< OptionBytes,OptionBytesCompare >::iterator

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::key_type const &

        """
        return _libdivvun.OptionSetBytes_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(OptionSetBytes self, OptionBytes x) -> std::set< OptionBytes,OptionBytesCompare >::iterator

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::key_type const &

        """
        return _libdivvun.OptionSetBytes_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(OptionSetBytes self, OptionBytes x) -> std::set< OptionBytes,OptionBytesCompare >::iterator

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::key_type const &

        """
        return _libdivvun.OptionSetBytes_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(OptionSetBytes self, OptionBytes x) -> std::pair< std::set< OptionBytes,OptionBytesCompare >::iterator,std::set< OptionBytes,OptionBytesCompare >::iterator >

        Parameters
        ----------
        x: std::set< OptionBytes,OptionBytesCompare >::key_type const &

        """
        return _libdivvun.OptionSetBytes_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(OptionSetBytes self, OptionBytes __x) -> std::pair< std::set< OptionBytes,OptionBytesCompare >::iterator,bool >

        Parameters
        ----------
        __x: std::set< OptionBytes,OptionBytesCompare >::value_type const &

        """
        return _libdivvun.OptionSetBytes_insert(self, __x)
    __swig_destroy__ = _libdivvun.delete_OptionSetBytes

# Register OptionSetBytes in _libdivvun:
_libdivvun.OptionSetBytes_swigregister(OptionSetBytes)
class LocalisedPrefsBytes(object):
    r"""Proxy of C++ std::map< divvun::Lang,PrefsBytes > class."""

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

    def iterator(self):
        r"""iterator(LocalisedPrefsBytes self) -> SwigPyIterator"""
        return _libdivvun.LocalisedPrefsBytes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(LocalisedPrefsBytes self) -> bool"""
        return _libdivvun.LocalisedPrefsBytes___nonzero__(self)

    def __bool__(self):
        r"""__bool__(LocalisedPrefsBytes self) -> bool"""
        return _libdivvun.LocalisedPrefsBytes___bool__(self)

    def __len__(self):
        r"""__len__(LocalisedPrefsBytes self) -> std::map< std::string,PrefsBytes >::size_type"""
        return _libdivvun.LocalisedPrefsBytes___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):
        r"""
        __getitem__(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & key) -> PrefsBytes

        Parameters
        ----------
        key: std::map< std::string,PrefsBytes >::key_type const &

        """
        return _libdivvun.LocalisedPrefsBytes___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,PrefsBytes >::key_type const &

        """
        return _libdivvun.LocalisedPrefsBytes___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,PrefsBytes >::key_type const &

        """
        return _libdivvun.LocalisedPrefsBytes_has_key(self, key)

    def keys(self):
        r"""keys(LocalisedPrefsBytes self) -> PyObject *"""
        return _libdivvun.LocalisedPrefsBytes_keys(self)

    def values(self):
        r"""values(LocalisedPrefsBytes self) -> PyObject *"""
        return _libdivvun.LocalisedPrefsBytes_values(self)

    def items(self):
        r"""items(LocalisedPrefsBytes self) -> PyObject *"""
        return _libdivvun.LocalisedPrefsBytes_items(self)

    def __contains__(self, key):
        r"""
        __contains__(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & key) -> bool

        Parameters
        ----------
        key: std::map< std::string,PrefsBytes >::key_type const &

        """
        return _libdivvun.LocalisedPrefsBytes___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(LocalisedPrefsBytes self) -> SwigPyIterator"""
        return _libdivvun.LocalisedPrefsBytes_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(LocalisedPrefsBytes self) -> SwigPyIterator"""
        return _libdivvun.LocalisedPrefsBytes_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & key)

        Parameters
        ----------
        key: std::map< std::string,PrefsBytes >::key_type const &

        __setitem__(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & key, PrefsBytes x)

        Parameters
        ----------
        key: std::map< std::string,PrefsBytes >::key_type const &
        x: std::map< std::string,PrefsBytes >::mapped_type const &

        """
        return _libdivvun.LocalisedPrefsBytes___setitem__(self, *args)

    def asdict(self):
        r"""asdict(LocalisedPrefsBytes self) -> PyObject *"""
        return _libdivvun.LocalisedPrefsBytes_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(LocalisedPrefsBytes self, std::less< std::string > const & other) -> LocalisedPrefsBytes

        Parameters
        ----------
        other: std::less< std::string > const &

        __init__(LocalisedPrefsBytes self) -> LocalisedPrefsBytes
        __init__(LocalisedPrefsBytes self, LocalisedPrefsBytes other) -> LocalisedPrefsBytes

        Parameters
        ----------
        other: std::map< divvun::Lang,PrefsBytes > const &

        """
        _libdivvun.LocalisedPrefsBytes_swiginit(self, _libdivvun.new_LocalisedPrefsBytes(*args))

    def empty(self):
        r"""empty(LocalisedPrefsBytes self) -> bool"""
        return _libdivvun.LocalisedPrefsBytes_empty(self)

    def size(self):
        r"""size(LocalisedPrefsBytes self) -> std::map< std::string,PrefsBytes >::size_type"""
        return _libdivvun.LocalisedPrefsBytes_size(self)

    def swap(self, v):
        r"""
        swap(LocalisedPrefsBytes self, LocalisedPrefsBytes v)

        Parameters
        ----------
        v: std::map< divvun::Lang,PrefsBytes > &

        """
        return _libdivvun.LocalisedPrefsBytes_swap(self, v)

    def begin(self):
        r"""begin(LocalisedPrefsBytes self) -> std::map< std::string,PrefsBytes >::iterator"""
        return _libdivvun.LocalisedPrefsBytes_begin(self)

    def end(self):
        r"""end(LocalisedPrefsBytes self) -> std::map< std::string,PrefsBytes >::iterator"""
        return _libdivvun.LocalisedPrefsBytes_end(self)

    def rbegin(self):
        r"""rbegin(LocalisedPrefsBytes self) -> std::map< std::string,PrefsBytes >::reverse_iterator"""
        return _libdivvun.LocalisedPrefsBytes_rbegin(self)

    def rend(self):
        r"""rend(LocalisedPrefsBytes self) -> std::map< std::string,PrefsBytes >::reverse_iterator"""
        return _libdivvun.LocalisedPrefsBytes_rend(self)

    def clear(self):
        r"""clear(LocalisedPrefsBytes self)"""
        return _libdivvun.LocalisedPrefsBytes_clear(self)

    def get_allocator(self):
        r"""get_allocator(LocalisedPrefsBytes self) -> std::map< std::string,PrefsBytes >::allocator_type"""
        return _libdivvun.LocalisedPrefsBytes_get_allocator(self)

    def count(self, x):
        r"""
        count(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & x) -> std::map< std::string,PrefsBytes >::size_type

        Parameters
        ----------
        x: std::map< std::string,PrefsBytes >::key_type const &

        """
        return _libdivvun.LocalisedPrefsBytes_count(self, x)

    def erase(self, *args):
        r"""
        erase(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & x) -> std::map< std::string,PrefsBytes >::size_type

        Parameters
        ----------
        x: std::map< std::string,PrefsBytes >::key_type const &

        erase(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::iterator position)

        Parameters
        ----------
        position: std::map< std::string,PrefsBytes >::iterator

        erase(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::iterator first, std::map< std::string,PrefsBytes >::iterator last)

        Parameters
        ----------
        first: std::map< std::string,PrefsBytes >::iterator
        last: std::map< std::string,PrefsBytes >::iterator

        """
        return _libdivvun.LocalisedPrefsBytes_erase(self, *args)

    def find(self, x):
        r"""
        find(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & x) -> std::map< std::string,PrefsBytes >::iterator

        Parameters
        ----------
        x: std::map< std::string,PrefsBytes >::key_type const &

        """
        return _libdivvun.LocalisedPrefsBytes_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & x) -> std::map< std::string,PrefsBytes >::iterator

        Parameters
        ----------
        x: std::map< std::string,PrefsBytes >::key_type const &

        """
        return _libdivvun.LocalisedPrefsBytes_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(LocalisedPrefsBytes self, std::map< std::string,PrefsBytes >::key_type const & x) -> std::map< std::string,PrefsBytes >::iterator

        Parameters
        ----------
        x: std::map< std::string,PrefsBytes >::key_type const &

        """
        return _libdivvun.LocalisedPrefsBytes_upper_bound(self, x)
    __swig_destroy__ = _libdivvun.delete_LocalisedPrefsBytes

# Register LocalisedPrefsBytes in _libdivvun:
_libdivvun.LocalisedPrefsBytes_swigregister(LocalisedPrefsBytes)

def toUtf8(_from):
    r"""
    toUtf8(std::u16string const & _from) -> std::string const

    Parameters
    ----------
    from: std::u16string const &

    """
    return _libdivvun.toUtf8(_from)

def proc_errs_bytes(checker, input):
    r"""
    proc_errs_bytes(CheckerUniquePtr checker, std::string const & input) -> ErrBytesVector

    Parameters
    ----------
    checker: std::unique_ptr< divvun::Checker > &
    input: std::string const &

    """
    return _libdivvun.proc_errs_bytes(checker, input)

def prefs_bytes(checker):
    r"""
    prefs_bytes(CheckerUniquePtr checker) -> LocalisedPrefsBytes

    Parameters
    ----------
    checker: std::unique_ptr< divvun::Checker > &

    """
    return _libdivvun.prefs_bytes(checker)

