# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# 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
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_znc_core', [dirname(__file__)])
        except ImportError:
            import _znc_core
            return _znc_core
        if fp is not None:
            try:
                _mod = imp.load_module('_znc_core', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _znc_core = swig_import_helper()
    del swig_import_helper
else:
    import _znc_core
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


import collections
class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

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

    def value(self) -> "PyObject *":
        return _znc_core.SwigPyIterator_value(self)

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

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

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

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

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

    def next(self) -> "PyObject *":
        return _znc_core.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        return _znc_core.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        return _znc_core.SwigPyIterator_previous(self)

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

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

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

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

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

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

    def __sub__(self, *args) -> "ptrdiff_t":
        return _znc_core.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _znc_core.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


_znc_core.SHARED_PTR_DISOWN_swigconstant(_znc_core)
SHARED_PTR_DISOWN = _znc_core.SHARED_PTR_DISOWN
class _stringlist(collections.MutableSequence):
    __swig_setmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _stringlist, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, _stringlist, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core._stringlist_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core._stringlist___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core._stringlist___bool__(self)

    def __len__(self) -> "std::list< CString >::size_type":
        return _znc_core._stringlist___len__(self)

    def pop(self) -> "std::list< CString >::value_type":
        return _znc_core._stringlist_pop(self)

    def __getslice__(self, i: 'std::list< CString >::difference_type', j: 'std::list< CString >::difference_type') -> "std::list< CString,std::allocator< CString > > *":
        return _znc_core._stringlist___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core._stringlist___setslice__(self, *args)

    def __delslice__(self, i: 'std::list< CString >::difference_type', j: 'std::list< CString >::difference_type') -> "void":
        return _znc_core._stringlist___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core._stringlist___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::list< CString >::value_type const &":
        return _znc_core._stringlist___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core._stringlist___setitem__(self, *args)

    def append(self, x: 'std::list< CString >::value_type const &') -> "void":
        return _znc_core._stringlist_append(self, x)

    def empty(self) -> "bool":
        return _znc_core._stringlist_empty(self)

    def size(self) -> "std::list< CString >::size_type":
        return _znc_core._stringlist_size(self)

    def clear(self) -> "void":
        return _znc_core._stringlist_clear(self)

    def swap(self, v: '_stringlist') -> "void":
        return _znc_core._stringlist_swap(self, v)

    def get_allocator(self) -> "std::list< CString >::allocator_type":
        return _znc_core._stringlist_get_allocator(self)

    def begin(self) -> "std::list< CString >::iterator":
        return _znc_core._stringlist_begin(self)

    def end(self) -> "std::list< CString >::iterator":
        return _znc_core._stringlist_end(self)

    def rbegin(self) -> "std::list< CString >::reverse_iterator":
        return _znc_core._stringlist_rbegin(self)

    def rend(self) -> "std::list< CString >::reverse_iterator":
        return _znc_core._stringlist_rend(self)

    def pop_back(self) -> "void":
        return _znc_core._stringlist_pop_back(self)

    def erase(self, *args) -> "std::list< CString >::iterator":
        return _znc_core._stringlist_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new__stringlist(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'std::list< CString >::value_type const &') -> "void":
        return _znc_core._stringlist_push_back(self, x)

    def front(self) -> "std::list< CString >::value_type const &":
        return _znc_core._stringlist_front(self)

    def back(self) -> "std::list< CString >::value_type const &":
        return _znc_core._stringlist_back(self)

    def assign(self, n: 'std::list< CString >::size_type', x: 'std::list< CString >::value_type const &') -> "void":
        return _znc_core._stringlist_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core._stringlist_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core._stringlist_insert(self, *args)

    def pop_front(self) -> "void":
        return _znc_core._stringlist_pop_front(self)

    def push_front(self, x: 'std::list< CString >::value_type const &') -> "void":
        return _znc_core._stringlist_push_front(self, x)

    def reverse(self) -> "void":
        return _znc_core._stringlist_reverse(self)
    __swig_destroy__ = _znc_core.delete__stringlist
    __del__ = lambda self: None
_stringlist_swigregister = _znc_core._stringlist_swigregister
_stringlist_swigregister(_stringlist)

class VIRCNetworks(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VIRCNetworks, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VIRCNetworks, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.VIRCNetworks_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.VIRCNetworks___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.VIRCNetworks___bool__(self)

    def __len__(self) -> "std::vector< CIRCNetwork * >::size_type":
        return _znc_core.VIRCNetworks___len__(self)

    def pop(self) -> "std::vector< CIRCNetwork * >::value_type":
        return _znc_core.VIRCNetworks_pop(self)

    def __getslice__(self, i: 'std::vector< CIRCNetwork * >::difference_type', j: 'std::vector< CIRCNetwork * >::difference_type') -> "std::vector< CIRCNetwork *,std::allocator< CIRCNetwork * > > *":
        return _znc_core.VIRCNetworks___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.VIRCNetworks___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< CIRCNetwork * >::difference_type', j: 'std::vector< CIRCNetwork * >::difference_type') -> "void":
        return _znc_core.VIRCNetworks___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.VIRCNetworks___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< CIRCNetwork * >::value_type":
        return _znc_core.VIRCNetworks___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.VIRCNetworks___setitem__(self, *args)

    def append(self, x: 'CIRCNetwork') -> "void":
        return _znc_core.VIRCNetworks_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.VIRCNetworks_empty(self)

    def size(self) -> "std::vector< CIRCNetwork * >::size_type":
        return _znc_core.VIRCNetworks_size(self)

    def clear(self) -> "void":
        return _znc_core.VIRCNetworks_clear(self)

    def swap(self, v: 'VIRCNetworks') -> "void":
        return _znc_core.VIRCNetworks_swap(self, v)

    def get_allocator(self) -> "std::vector< CIRCNetwork * >::allocator_type":
        return _znc_core.VIRCNetworks_get_allocator(self)

    def begin(self) -> "std::vector< CIRCNetwork * >::iterator":
        return _znc_core.VIRCNetworks_begin(self)

    def end(self) -> "std::vector< CIRCNetwork * >::iterator":
        return _znc_core.VIRCNetworks_end(self)

    def rbegin(self) -> "std::vector< CIRCNetwork * >::reverse_iterator":
        return _znc_core.VIRCNetworks_rbegin(self)

    def rend(self) -> "std::vector< CIRCNetwork * >::reverse_iterator":
        return _znc_core.VIRCNetworks_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.VIRCNetworks_pop_back(self)

    def erase(self, *args) -> "std::vector< CIRCNetwork * >::iterator":
        return _znc_core.VIRCNetworks_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_VIRCNetworks(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'CIRCNetwork') -> "void":
        return _znc_core.VIRCNetworks_push_back(self, x)

    def front(self) -> "std::vector< CIRCNetwork * >::value_type":
        return _znc_core.VIRCNetworks_front(self)

    def back(self) -> "std::vector< CIRCNetwork * >::value_type":
        return _znc_core.VIRCNetworks_back(self)

    def assign(self, n: 'std::vector< CIRCNetwork * >::size_type', x: 'CIRCNetwork') -> "void":
        return _znc_core.VIRCNetworks_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.VIRCNetworks_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.VIRCNetworks_insert(self, *args)

    def reserve(self, n: 'std::vector< CIRCNetwork * >::size_type') -> "void":
        return _znc_core.VIRCNetworks_reserve(self, n)

    def capacity(self) -> "std::vector< CIRCNetwork * >::size_type":
        return _znc_core.VIRCNetworks_capacity(self)
    __swig_destroy__ = _znc_core.delete_VIRCNetworks
    __del__ = lambda self: None
VIRCNetworks_swigregister = _znc_core.VIRCNetworks_swigregister
VIRCNetworks_swigregister(VIRCNetworks)

class VChannels(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VChannels, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VChannels, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.VChannels_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.VChannels___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.VChannels___bool__(self)

    def __len__(self) -> "std::vector< CChan * >::size_type":
        return _znc_core.VChannels___len__(self)

    def pop(self) -> "std::vector< CChan * >::value_type":
        return _znc_core.VChannels_pop(self)

    def __getslice__(self, i: 'std::vector< CChan * >::difference_type', j: 'std::vector< CChan * >::difference_type') -> "std::vector< CChan *,std::allocator< CChan * > > *":
        return _znc_core.VChannels___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.VChannels___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< CChan * >::difference_type', j: 'std::vector< CChan * >::difference_type') -> "void":
        return _znc_core.VChannels___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.VChannels___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< CChan * >::value_type":
        return _znc_core.VChannels___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.VChannels___setitem__(self, *args)

    def append(self, x: 'CChan') -> "void":
        return _znc_core.VChannels_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.VChannels_empty(self)

    def size(self) -> "std::vector< CChan * >::size_type":
        return _znc_core.VChannels_size(self)

    def clear(self) -> "void":
        return _znc_core.VChannels_clear(self)

    def swap(self, v: 'VChannels') -> "void":
        return _znc_core.VChannels_swap(self, v)

    def get_allocator(self) -> "std::vector< CChan * >::allocator_type":
        return _znc_core.VChannels_get_allocator(self)

    def begin(self) -> "std::vector< CChan * >::iterator":
        return _znc_core.VChannels_begin(self)

    def end(self) -> "std::vector< CChan * >::iterator":
        return _znc_core.VChannels_end(self)

    def rbegin(self) -> "std::vector< CChan * >::reverse_iterator":
        return _znc_core.VChannels_rbegin(self)

    def rend(self) -> "std::vector< CChan * >::reverse_iterator":
        return _znc_core.VChannels_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.VChannels_pop_back(self)

    def erase(self, *args) -> "std::vector< CChan * >::iterator":
        return _znc_core.VChannels_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_VChannels(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'CChan') -> "void":
        return _znc_core.VChannels_push_back(self, x)

    def front(self) -> "std::vector< CChan * >::value_type":
        return _znc_core.VChannels_front(self)

    def back(self) -> "std::vector< CChan * >::value_type":
        return _znc_core.VChannels_back(self)

    def assign(self, n: 'std::vector< CChan * >::size_type', x: 'CChan') -> "void":
        return _znc_core.VChannels_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.VChannels_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.VChannels_insert(self, *args)

    def reserve(self, n: 'std::vector< CChan * >::size_type') -> "void":
        return _znc_core.VChannels_reserve(self, n)

    def capacity(self) -> "std::vector< CChan * >::size_type":
        return _znc_core.VChannels_capacity(self)
    __swig_destroy__ = _znc_core.delete_VChannels
    __del__ = lambda self: None
VChannels_swigregister = _znc_core.VChannels_swigregister
VChannels_swigregister(VChannels)

class MNicks(collections.MutableMapping):
    __swig_setmethods__ = {}
    for _s in [collections.MutableMapping]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MNicks, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableMapping]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MNicks, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.MNicks_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.MNicks___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.MNicks___bool__(self)

    def __len__(self) -> "std::map< CString,CNick >::size_type":
        return _znc_core.MNicks___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: 'std::map< CString,CNick >::key_type const &') -> "std::map< CString,CNick >::mapped_type const &":
        return _znc_core.MNicks___getitem__(self, key)

    def __delitem__(self, key: 'std::map< CString,CNick >::key_type const &') -> "void":
        return _znc_core.MNicks___delitem__(self, key)

    def has_key(self, key: 'std::map< CString,CNick >::key_type const &') -> "bool":
        return _znc_core.MNicks_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _znc_core.MNicks_keys(self)

    def values(self) -> "PyObject *":
        return _znc_core.MNicks_values(self)

    def items(self) -> "PyObject *":
        return _znc_core.MNicks_items(self)

    def __contains__(self, key: 'std::map< CString,CNick >::key_type const &') -> "bool":
        return _znc_core.MNicks___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.MNicks_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.MNicks_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _znc_core.MNicks___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _znc_core.MNicks_asdict(self)

    def __init__(self, *args):
        this = _znc_core.new_MNicks(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self) -> "bool":
        return _znc_core.MNicks_empty(self)

    def size(self) -> "std::map< CString,CNick >::size_type":
        return _znc_core.MNicks_size(self)

    def clear(self) -> "void":
        return _znc_core.MNicks_clear(self)

    def swap(self, v: 'MNicks') -> "void":
        return _znc_core.MNicks_swap(self, v)

    def get_allocator(self) -> "std::map< CString,CNick >::allocator_type":
        return _znc_core.MNicks_get_allocator(self)

    def begin(self) -> "std::map< CString,CNick >::iterator":
        return _znc_core.MNicks_begin(self)

    def end(self) -> "std::map< CString,CNick >::iterator":
        return _znc_core.MNicks_end(self)

    def rbegin(self) -> "std::map< CString,CNick >::reverse_iterator":
        return _znc_core.MNicks_rbegin(self)

    def rend(self) -> "std::map< CString,CNick >::reverse_iterator":
        return _znc_core.MNicks_rend(self)

    def count(self, x: 'std::map< CString,CNick >::key_type const &') -> "std::map< CString,CNick >::size_type":
        return _znc_core.MNicks_count(self, x)

    def erase(self, *args) -> "void":
        return _znc_core.MNicks_erase(self, *args)

    def find(self, x: 'std::map< CString,CNick >::key_type const &') -> "std::map< CString,CNick >::iterator":
        return _znc_core.MNicks_find(self, x)

    def lower_bound(self, x: 'std::map< CString,CNick >::key_type const &') -> "std::map< CString,CNick >::iterator":
        return _znc_core.MNicks_lower_bound(self, x)

    def upper_bound(self, x: 'std::map< CString,CNick >::key_type const &') -> "std::map< CString,CNick >::iterator":
        return _znc_core.MNicks_upper_bound(self, x)
    __swig_destroy__ = _znc_core.delete_MNicks
    __del__ = lambda self: None
MNicks_swigregister = _znc_core.MNicks_swigregister
MNicks_swigregister(MNicks)

class SModInfo(collections.MutableSet):
    __swig_setmethods__ = {}
    for _s in [collections.MutableSet]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SModInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableSet]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SModInfo, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.SModInfo_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.SModInfo___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.SModInfo___bool__(self)

    def __len__(self) -> "std::set< CModInfo >::size_type":
        return _znc_core.SModInfo___len__(self)

    def append(self, x: 'CModInfo') -> "void":
        return _znc_core.SModInfo_append(self, x)

    def __contains__(self, x: 'CModInfo') -> "bool":
        return _znc_core.SModInfo___contains__(self, x)

    def __getitem__(self, i: 'std::set< CModInfo >::difference_type') -> "std::set< CModInfo >::value_type":
        return _znc_core.SModInfo___getitem__(self, i)

    def add(self, x: 'CModInfo') -> "void":
        return _znc_core.SModInfo_add(self, x)

    def discard(self, x: 'CModInfo') -> "void":
        return _znc_core.SModInfo_discard(self, x)

    def __init__(self, *args):
        this = _znc_core.new_SModInfo(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self) -> "bool":
        return _znc_core.SModInfo_empty(self)

    def size(self) -> "std::set< CModInfo >::size_type":
        return _znc_core.SModInfo_size(self)

    def clear(self) -> "void":
        return _znc_core.SModInfo_clear(self)

    def swap(self, v: 'SModInfo') -> "void":
        return _znc_core.SModInfo_swap(self, v)

    def count(self, x: 'CModInfo') -> "std::set< CModInfo >::size_type":
        return _znc_core.SModInfo_count(self, x)

    def begin(self) -> "std::set< CModInfo >::iterator":
        return _znc_core.SModInfo_begin(self)

    def end(self) -> "std::set< CModInfo >::iterator":
        return _znc_core.SModInfo_end(self)

    def rbegin(self) -> "std::set< CModInfo >::reverse_iterator":
        return _znc_core.SModInfo_rbegin(self)

    def rend(self) -> "std::set< CModInfo >::reverse_iterator":
        return _znc_core.SModInfo_rend(self)

    def erase(self, *args) -> "void":
        return _znc_core.SModInfo_erase(self, *args)

    def find(self, x: 'CModInfo') -> "std::set< CModInfo >::iterator":
        return _znc_core.SModInfo_find(self, x)

    def lower_bound(self, x: 'CModInfo') -> "std::set< CModInfo >::iterator":
        return _znc_core.SModInfo_lower_bound(self, x)

    def upper_bound(self, x: 'CModInfo') -> "std::set< CModInfo >::iterator":
        return _znc_core.SModInfo_upper_bound(self, x)

    def equal_range(self, x: 'CModInfo') -> "std::pair< std::set< CModInfo >::iterator,std::set< CModInfo >::iterator >":
        return _znc_core.SModInfo_equal_range(self, x)

    def insert(self, __x: 'CModInfo') -> "std::pair< std::set< CModInfo >::iterator,bool >":
        return _znc_core.SModInfo_insert(self, __x)
    __swig_destroy__ = _znc_core.delete_SModInfo
    __del__ = lambda self: None
SModInfo_swigregister = _znc_core.SModInfo_swigregister
SModInfo_swigregister(SModInfo)

class SCString(collections.MutableSet):
    __swig_setmethods__ = {}
    for _s in [collections.MutableSet]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SCString, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableSet]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SCString, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.SCString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.SCString___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.SCString___bool__(self)

    def __len__(self) -> "std::set< CString >::size_type":
        return _znc_core.SCString___len__(self)

    def append(self, x: 'std::set< CString >::value_type') -> "void":
        return _znc_core.SCString_append(self, x)

    def __contains__(self, x: 'std::set< CString >::value_type') -> "bool":
        return _znc_core.SCString___contains__(self, x)

    def __getitem__(self, i: 'std::set< CString >::difference_type') -> "std::set< CString >::value_type":
        return _znc_core.SCString___getitem__(self, i)

    def add(self, x: 'std::set< CString >::value_type') -> "void":
        return _znc_core.SCString_add(self, x)

    def discard(self, x: 'std::set< CString >::value_type') -> "void":
        return _znc_core.SCString_discard(self, x)

    def __init__(self, *args):
        this = _znc_core.new_SCString(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self) -> "bool":
        return _znc_core.SCString_empty(self)

    def size(self) -> "std::set< CString >::size_type":
        return _znc_core.SCString_size(self)

    def clear(self) -> "void":
        return _znc_core.SCString_clear(self)

    def swap(self, v: 'SCString') -> "void":
        return _znc_core.SCString_swap(self, v)

    def count(self, x: 'std::set< CString >::key_type const &') -> "std::set< CString >::size_type":
        return _znc_core.SCString_count(self, x)

    def begin(self) -> "std::set< CString >::iterator":
        return _znc_core.SCString_begin(self)

    def end(self) -> "std::set< CString >::iterator":
        return _znc_core.SCString_end(self)

    def rbegin(self) -> "std::set< CString >::reverse_iterator":
        return _znc_core.SCString_rbegin(self)

    def rend(self) -> "std::set< CString >::reverse_iterator":
        return _znc_core.SCString_rend(self)

    def erase(self, *args) -> "void":
        return _znc_core.SCString_erase(self, *args)

    def find(self, x: 'std::set< CString >::key_type const &') -> "std::set< CString >::iterator":
        return _znc_core.SCString_find(self, x)

    def lower_bound(self, x: 'std::set< CString >::key_type const &') -> "std::set< CString >::iterator":
        return _znc_core.SCString_lower_bound(self, x)

    def upper_bound(self, x: 'std::set< CString >::key_type const &') -> "std::set< CString >::iterator":
        return _znc_core.SCString_upper_bound(self, x)

    def equal_range(self, x: 'std::set< CString >::key_type const &') -> "std::pair< std::set< CString >::iterator,std::set< CString >::iterator >":
        return _znc_core.SCString_equal_range(self, x)

    def insert(self, __x: 'std::set< CString >::value_type const &') -> "std::pair< std::set< CString >::iterator,bool >":
        return _znc_core.SCString_insert(self, __x)
    __swig_destroy__ = _znc_core.delete_SCString
    __del__ = lambda self: None
SCString_swigregister = _znc_core.SCString_swigregister
SCString_swigregister(SCString)

class VCString(collections.MutableSequence):
    __swig_setmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VCString, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VCString, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.VCString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.VCString___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.VCString___bool__(self)

    def __len__(self) -> "std::vector< CString >::size_type":
        return _znc_core.VCString___len__(self)

    def pop(self) -> "std::vector< CString >::value_type":
        return _znc_core.VCString_pop(self)

    def __getslice__(self, i: 'std::vector< CString >::difference_type', j: 'std::vector< CString >::difference_type') -> "std::vector< CString,std::allocator< CString > > *":
        return _znc_core.VCString___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.VCString___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< CString >::difference_type', j: 'std::vector< CString >::difference_type') -> "void":
        return _znc_core.VCString___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.VCString___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< CString >::value_type const &":
        return _znc_core.VCString___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.VCString___setitem__(self, *args)

    def append(self, x: 'std::vector< CString >::value_type const &') -> "void":
        return _znc_core.VCString_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.VCString_empty(self)

    def size(self) -> "std::vector< CString >::size_type":
        return _znc_core.VCString_size(self)

    def clear(self) -> "void":
        return _znc_core.VCString_clear(self)

    def swap(self, v: 'VCString') -> "void":
        return _znc_core.VCString_swap(self, v)

    def get_allocator(self) -> "std::vector< CString >::allocator_type":
        return _znc_core.VCString_get_allocator(self)

    def begin(self) -> "std::vector< CString >::iterator":
        return _znc_core.VCString_begin(self)

    def end(self) -> "std::vector< CString >::iterator":
        return _znc_core.VCString_end(self)

    def rbegin(self) -> "std::vector< CString >::reverse_iterator":
        return _znc_core.VCString_rbegin(self)

    def rend(self) -> "std::vector< CString >::reverse_iterator":
        return _znc_core.VCString_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.VCString_pop_back(self)

    def erase(self, *args) -> "std::vector< CString >::iterator":
        return _znc_core.VCString_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_VCString(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'std::vector< CString >::value_type const &') -> "void":
        return _znc_core.VCString_push_back(self, x)

    def front(self) -> "std::vector< CString >::value_type const &":
        return _znc_core.VCString_front(self)

    def back(self) -> "std::vector< CString >::value_type const &":
        return _znc_core.VCString_back(self)

    def assign(self, n: 'std::vector< CString >::size_type', x: 'std::vector< CString >::value_type const &') -> "void":
        return _znc_core.VCString_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.VCString_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.VCString_insert(self, *args)

    def reserve(self, n: 'std::vector< CString >::size_type') -> "void":
        return _znc_core.VCString_reserve(self, n)

    def capacity(self) -> "std::vector< CString >::size_type":
        return _znc_core.VCString_capacity(self)
    __swig_destroy__ = _znc_core.delete_VCString
    __del__ = lambda self: None
VCString_swigregister = _znc_core.VCString_swigregister
VCString_swigregister(VCString)

class PyMCString(collections.MutableMapping):
    __swig_setmethods__ = {}
    for _s in [collections.MutableMapping]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyMCString, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableMapping]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PyMCString, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.PyMCString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.PyMCString___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.PyMCString___bool__(self)

    def __len__(self) -> "std::map< CString,CString >::size_type":
        return _znc_core.PyMCString___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: 'std::map< CString,CString >::key_type const &') -> "std::map< CString,CString >::mapped_type const &":
        return _znc_core.PyMCString___getitem__(self, key)

    def __delitem__(self, key: 'std::map< CString,CString >::key_type const &') -> "void":
        return _znc_core.PyMCString___delitem__(self, key)

    def has_key(self, key: 'std::map< CString,CString >::key_type const &') -> "bool":
        return _znc_core.PyMCString_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _znc_core.PyMCString_keys(self)

    def values(self) -> "PyObject *":
        return _znc_core.PyMCString_values(self)

    def items(self) -> "PyObject *":
        return _znc_core.PyMCString_items(self)

    def __contains__(self, key: 'std::map< CString,CString >::key_type const &') -> "bool":
        return _znc_core.PyMCString___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.PyMCString_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.PyMCString_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _znc_core.PyMCString___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _znc_core.PyMCString_asdict(self)

    def __init__(self, *args):
        this = _znc_core.new_PyMCString(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self) -> "bool":
        return _znc_core.PyMCString_empty(self)

    def size(self) -> "std::map< CString,CString >::size_type":
        return _znc_core.PyMCString_size(self)

    def clear(self) -> "void":
        return _znc_core.PyMCString_clear(self)

    def swap(self, v: 'PyMCString') -> "void":
        return _znc_core.PyMCString_swap(self, v)

    def get_allocator(self) -> "std::map< CString,CString >::allocator_type":
        return _znc_core.PyMCString_get_allocator(self)

    def begin(self) -> "std::map< CString,CString >::iterator":
        return _znc_core.PyMCString_begin(self)

    def end(self) -> "std::map< CString,CString >::iterator":
        return _znc_core.PyMCString_end(self)

    def rbegin(self) -> "std::map< CString,CString >::reverse_iterator":
        return _znc_core.PyMCString_rbegin(self)

    def rend(self) -> "std::map< CString,CString >::reverse_iterator":
        return _znc_core.PyMCString_rend(self)

    def count(self, x: 'std::map< CString,CString >::key_type const &') -> "std::map< CString,CString >::size_type":
        return _znc_core.PyMCString_count(self, x)

    def erase(self, *args) -> "void":
        return _znc_core.PyMCString_erase(self, *args)

    def find(self, x: 'std::map< CString,CString >::key_type const &') -> "std::map< CString,CString >::iterator":
        return _znc_core.PyMCString_find(self, x)

    def lower_bound(self, x: 'std::map< CString,CString >::key_type const &') -> "std::map< CString,CString >::iterator":
        return _znc_core.PyMCString_lower_bound(self, x)

    def upper_bound(self, x: 'std::map< CString,CString >::key_type const &') -> "std::map< CString,CString >::iterator":
        return _znc_core.PyMCString_upper_bound(self, x)
    __swig_destroy__ = _znc_core.delete_PyMCString
    __del__ = lambda self: None
PyMCString_swigregister = _znc_core.PyMCString_swigregister
PyMCString_swigregister(PyMCString)

class PyMStringVString(collections.MutableMapping):
    __swig_setmethods__ = {}
    for _s in [collections.MutableMapping]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyMStringVString, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableMapping]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PyMStringVString, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.PyMStringVString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.PyMStringVString___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.PyMStringVString___bool__(self)

    def __len__(self) -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::size_type":
        return _znc_core.PyMStringVString___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: 'std::map< CString,std::vector< CString,std::allocator< CString > > >::key_type const &') -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::mapped_type const &":
        return _znc_core.PyMStringVString___getitem__(self, key)

    def __delitem__(self, key: 'std::map< CString,std::vector< CString,std::allocator< CString > > >::key_type const &') -> "void":
        return _znc_core.PyMStringVString___delitem__(self, key)

    def has_key(self, key: 'std::map< CString,std::vector< CString,std::allocator< CString > > >::key_type const &') -> "bool":
        return _znc_core.PyMStringVString_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _znc_core.PyMStringVString_keys(self)

    def values(self) -> "PyObject *":
        return _znc_core.PyMStringVString_values(self)

    def items(self) -> "PyObject *":
        return _znc_core.PyMStringVString_items(self)

    def __contains__(self, key: 'std::map< CString,std::vector< CString,std::allocator< CString > > >::key_type const &') -> "bool":
        return _znc_core.PyMStringVString___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.PyMStringVString_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.PyMStringVString_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _znc_core.PyMStringVString___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _znc_core.PyMStringVString_asdict(self)

    def __init__(self, *args):
        this = _znc_core.new_PyMStringVString(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self) -> "bool":
        return _znc_core.PyMStringVString_empty(self)

    def size(self) -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::size_type":
        return _znc_core.PyMStringVString_size(self)

    def clear(self) -> "void":
        return _znc_core.PyMStringVString_clear(self)

    def swap(self, v: 'PyMStringVString') -> "void":
        return _znc_core.PyMStringVString_swap(self, v)

    def get_allocator(self) -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::allocator_type":
        return _znc_core.PyMStringVString_get_allocator(self)

    def begin(self) -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::iterator":
        return _znc_core.PyMStringVString_begin(self)

    def end(self) -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::iterator":
        return _znc_core.PyMStringVString_end(self)

    def rbegin(self) -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::reverse_iterator":
        return _znc_core.PyMStringVString_rbegin(self)

    def rend(self) -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::reverse_iterator":
        return _znc_core.PyMStringVString_rend(self)

    def count(self, x: 'std::map< CString,std::vector< CString,std::allocator< CString > > >::key_type const &') -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::size_type":
        return _znc_core.PyMStringVString_count(self, x)

    def erase(self, *args) -> "void":
        return _znc_core.PyMStringVString_erase(self, *args)

    def find(self, x: 'std::map< CString,std::vector< CString,std::allocator< CString > > >::key_type const &') -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::iterator":
        return _znc_core.PyMStringVString_find(self, x)

    def lower_bound(self, x: 'std::map< CString,std::vector< CString,std::allocator< CString > > >::key_type const &') -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::iterator":
        return _znc_core.PyMStringVString_lower_bound(self, x)

    def upper_bound(self, x: 'std::map< CString,std::vector< CString,std::allocator< CString > > >::key_type const &') -> "std::map< CString,std::vector< CString,std::allocator< CString > > >::iterator":
        return _znc_core.PyMStringVString_upper_bound(self, x)
    __swig_destroy__ = _znc_core.delete_PyMStringVString
    __del__ = lambda self: None
PyMStringVString_swigregister = _znc_core.PyMStringVString_swigregister
PyMStringVString_swigregister(PyMStringVString)

class MCString(PyMCString):
    __swig_setmethods__ = {}
    for _s in [PyMCString]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCString, name, value)
    __swig_getmethods__ = {}
    for _s in [PyMCString]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MCString, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_MCString()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_MCString
    __del__ = lambda self: None
MCString_swigregister = _znc_core.MCString_swigregister
MCString_swigregister(MCString)

class PyModulesVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyModulesVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PyModulesVector, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.PyModulesVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.PyModulesVector___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.PyModulesVector___bool__(self)

    def __len__(self) -> "std::vector< CModule * >::size_type":
        return _znc_core.PyModulesVector___len__(self)

    def pop(self) -> "std::vector< CModule * >::value_type":
        return _znc_core.PyModulesVector_pop(self)

    def __getslice__(self, i: 'std::vector< CModule * >::difference_type', j: 'std::vector< CModule * >::difference_type') -> "std::vector< CModule *,std::allocator< CModule * > > *":
        return _znc_core.PyModulesVector___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.PyModulesVector___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< CModule * >::difference_type', j: 'std::vector< CModule * >::difference_type') -> "void":
        return _znc_core.PyModulesVector___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.PyModulesVector___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< CModule * >::value_type":
        return _znc_core.PyModulesVector___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.PyModulesVector___setitem__(self, *args)

    def append(self, x: 'CModule') -> "void":
        return _znc_core.PyModulesVector_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.PyModulesVector_empty(self)

    def size(self) -> "std::vector< CModule * >::size_type":
        return _znc_core.PyModulesVector_size(self)

    def clear(self) -> "void":
        return _znc_core.PyModulesVector_clear(self)

    def swap(self, v: 'PyModulesVector') -> "void":
        return _znc_core.PyModulesVector_swap(self, v)

    def get_allocator(self) -> "std::vector< CModule * >::allocator_type":
        return _znc_core.PyModulesVector_get_allocator(self)

    def begin(self) -> "std::vector< CModule * >::iterator":
        return _znc_core.PyModulesVector_begin(self)

    def end(self) -> "std::vector< CModule * >::iterator":
        return _znc_core.PyModulesVector_end(self)

    def rbegin(self) -> "std::vector< CModule * >::reverse_iterator":
        return _znc_core.PyModulesVector_rbegin(self)

    def rend(self) -> "std::vector< CModule * >::reverse_iterator":
        return _znc_core.PyModulesVector_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.PyModulesVector_pop_back(self)

    def erase(self, *args) -> "std::vector< CModule * >::iterator":
        return _znc_core.PyModulesVector_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_PyModulesVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'CModule') -> "void":
        return _znc_core.PyModulesVector_push_back(self, x)

    def front(self) -> "std::vector< CModule * >::value_type":
        return _znc_core.PyModulesVector_front(self)

    def back(self) -> "std::vector< CModule * >::value_type":
        return _znc_core.PyModulesVector_back(self)

    def assign(self, n: 'std::vector< CModule * >::size_type', x: 'CModule') -> "void":
        return _znc_core.PyModulesVector_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.PyModulesVector_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.PyModulesVector_insert(self, *args)

    def reserve(self, n: 'std::vector< CModule * >::size_type') -> "void":
        return _znc_core.PyModulesVector_reserve(self, n)

    def capacity(self) -> "std::vector< CModule * >::size_type":
        return _znc_core.PyModulesVector_capacity(self)
    __swig_destroy__ = _znc_core.delete_PyModulesVector
    __del__ = lambda self: None
PyModulesVector_swigregister = _znc_core.PyModulesVector_swigregister
PyModulesVector_swigregister(PyModulesVector)

class VListeners(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VListeners, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VListeners, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.VListeners_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.VListeners___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.VListeners___bool__(self)

    def __len__(self) -> "std::vector< CListener * >::size_type":
        return _znc_core.VListeners___len__(self)

    def pop(self) -> "std::vector< CListener * >::value_type":
        return _znc_core.VListeners_pop(self)

    def __getslice__(self, i: 'std::vector< CListener * >::difference_type', j: 'std::vector< CListener * >::difference_type') -> "std::vector< CListener *,std::allocator< CListener * > > *":
        return _znc_core.VListeners___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.VListeners___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< CListener * >::difference_type', j: 'std::vector< CListener * >::difference_type') -> "void":
        return _znc_core.VListeners___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.VListeners___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< CListener * >::value_type":
        return _znc_core.VListeners___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.VListeners___setitem__(self, *args)

    def append(self, x: 'CListener') -> "void":
        return _znc_core.VListeners_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.VListeners_empty(self)

    def size(self) -> "std::vector< CListener * >::size_type":
        return _znc_core.VListeners_size(self)

    def clear(self) -> "void":
        return _znc_core.VListeners_clear(self)

    def swap(self, v: 'VListeners') -> "void":
        return _znc_core.VListeners_swap(self, v)

    def get_allocator(self) -> "std::vector< CListener * >::allocator_type":
        return _znc_core.VListeners_get_allocator(self)

    def begin(self) -> "std::vector< CListener * >::iterator":
        return _znc_core.VListeners_begin(self)

    def end(self) -> "std::vector< CListener * >::iterator":
        return _znc_core.VListeners_end(self)

    def rbegin(self) -> "std::vector< CListener * >::reverse_iterator":
        return _znc_core.VListeners_rbegin(self)

    def rend(self) -> "std::vector< CListener * >::reverse_iterator":
        return _znc_core.VListeners_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.VListeners_pop_back(self)

    def erase(self, *args) -> "std::vector< CListener * >::iterator":
        return _znc_core.VListeners_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_VListeners(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'CListener') -> "void":
        return _znc_core.VListeners_push_back(self, x)

    def front(self) -> "std::vector< CListener * >::value_type":
        return _znc_core.VListeners_front(self)

    def back(self) -> "std::vector< CListener * >::value_type":
        return _znc_core.VListeners_back(self)

    def assign(self, n: 'std::vector< CListener * >::size_type', x: 'CListener') -> "void":
        return _znc_core.VListeners_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.VListeners_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.VListeners_insert(self, *args)

    def reserve(self, n: 'std::vector< CListener * >::size_type') -> "void":
        return _znc_core.VListeners_reserve(self, n)

    def capacity(self) -> "std::vector< CListener * >::size_type":
        return _znc_core.VListeners_capacity(self)
    __swig_destroy__ = _znc_core.delete_VListeners
    __del__ = lambda self: None
VListeners_swigregister = _znc_core.VListeners_swigregister
VListeners_swigregister(VListeners)

class BufLines(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BufLines, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BufLines, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.BufLines_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.BufLines___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.BufLines___bool__(self)

    def __len__(self) -> "std::deque< CBufLine >::size_type":
        return _znc_core.BufLines___len__(self)

    def pop(self) -> "std::deque< CBufLine >::value_type":
        return _znc_core.BufLines_pop(self)

    def __getslice__(self, i: 'std::deque< CBufLine >::difference_type', j: 'std::deque< CBufLine >::difference_type') -> "std::deque< CBufLine,std::allocator< CBufLine > > *":
        return _znc_core.BufLines___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.BufLines___setslice__(self, *args)

    def __delslice__(self, i: 'std::deque< CBufLine >::difference_type', j: 'std::deque< CBufLine >::difference_type') -> "void":
        return _znc_core.BufLines___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.BufLines___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::deque< CBufLine >::value_type const &":
        return _znc_core.BufLines___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.BufLines___setitem__(self, *args)

    def append(self, x: 'CBufLine') -> "void":
        return _znc_core.BufLines_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.BufLines_empty(self)

    def size(self) -> "std::deque< CBufLine >::size_type":
        return _znc_core.BufLines_size(self)

    def clear(self) -> "void":
        return _znc_core.BufLines_clear(self)

    def swap(self, v: 'BufLines') -> "void":
        return _znc_core.BufLines_swap(self, v)

    def get_allocator(self) -> "std::deque< CBufLine >::allocator_type":
        return _znc_core.BufLines_get_allocator(self)

    def begin(self) -> "std::deque< CBufLine >::iterator":
        return _znc_core.BufLines_begin(self)

    def end(self) -> "std::deque< CBufLine >::iterator":
        return _znc_core.BufLines_end(self)

    def rbegin(self) -> "std::deque< CBufLine >::reverse_iterator":
        return _znc_core.BufLines_rbegin(self)

    def rend(self) -> "std::deque< CBufLine >::reverse_iterator":
        return _znc_core.BufLines_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.BufLines_pop_back(self)

    def erase(self, *args) -> "std::deque< CBufLine >::iterator":
        return _znc_core.BufLines_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_BufLines(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'CBufLine') -> "void":
        return _znc_core.BufLines_push_back(self, x)

    def front(self) -> "std::deque< CBufLine >::value_type const &":
        return _znc_core.BufLines_front(self)

    def back(self) -> "std::deque< CBufLine >::value_type const &":
        return _znc_core.BufLines_back(self)

    def assign(self, n: 'std::deque< CBufLine >::size_type', x: 'CBufLine') -> "void":
        return _znc_core.BufLines_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.BufLines_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.BufLines_insert(self, *args)

    def pop_front(self) -> "void":
        return _znc_core.BufLines_pop_front(self)

    def push_front(self, x: 'CBufLine') -> "void":
        return _znc_core.BufLines_push_front(self, x)
    __swig_destroy__ = _znc_core.delete_BufLines
    __del__ = lambda self: None
BufLines_swigregister = _znc_core.BufLines_swigregister
BufLines_swigregister(BufLines)

class VVString(collections.MutableSequence):
    __swig_setmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VVString, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VVString, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.VVString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.VVString___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.VVString___bool__(self)

    def __len__(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::size_type":
        return _znc_core.VVString___len__(self)

    def pop(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::value_type":
        return _znc_core.VVString_pop(self)

    def __getslice__(self, i: 'std::vector< std::vector< CString,std::allocator< CString > > >::difference_type', j: 'std::vector< std::vector< CString,std::allocator< CString > > >::difference_type') -> "std::vector< std::vector< CString,std::allocator< CString > >,std::allocator< std::vector< CString,std::allocator< CString > > > > *":
        return _znc_core.VVString___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.VVString___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< std::vector< CString,std::allocator< CString > > >::difference_type', j: 'std::vector< std::vector< CString,std::allocator< CString > > >::difference_type') -> "void":
        return _znc_core.VVString___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.VVString___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::vector< CString,std::allocator< CString > > >::value_type const &":
        return _znc_core.VVString___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.VVString___setitem__(self, *args)

    def append(self, x: 'VCString') -> "void":
        return _znc_core.VVString_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.VVString_empty(self)

    def size(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::size_type":
        return _znc_core.VVString_size(self)

    def clear(self) -> "void":
        return _znc_core.VVString_clear(self)

    def swap(self, v: 'VVString') -> "void":
        return _znc_core.VVString_swap(self, v)

    def get_allocator(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::allocator_type":
        return _znc_core.VVString_get_allocator(self)

    def begin(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::iterator":
        return _znc_core.VVString_begin(self)

    def end(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::iterator":
        return _znc_core.VVString_end(self)

    def rbegin(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::reverse_iterator":
        return _znc_core.VVString_rbegin(self)

    def rend(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::reverse_iterator":
        return _znc_core.VVString_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.VVString_pop_back(self)

    def erase(self, *args) -> "std::vector< std::vector< CString,std::allocator< CString > > >::iterator":
        return _znc_core.VVString_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_VVString(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'VCString') -> "void":
        return _znc_core.VVString_push_back(self, x)

    def front(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::value_type const &":
        return _znc_core.VVString_front(self)

    def back(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::value_type const &":
        return _znc_core.VVString_back(self)

    def assign(self, n: 'std::vector< std::vector< CString,std::allocator< CString > > >::size_type', x: 'VCString') -> "void":
        return _znc_core.VVString_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.VVString_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.VVString_insert(self, *args)

    def reserve(self, n: 'std::vector< std::vector< CString,std::allocator< CString > > >::size_type') -> "void":
        return _znc_core.VVString_reserve(self, n)

    def capacity(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::size_type":
        return _znc_core.VVString_capacity(self)
    __swig_destroy__ = _znc_core.delete_VVString
    __del__ = lambda self: None
VVString_swigregister = _znc_core.VVString_swigregister
VVString_swigregister(VVString)

class VClients(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VClients, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VClients, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.VClients_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.VClients___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.VClients___bool__(self)

    def __len__(self) -> "std::vector< CClient * >::size_type":
        return _znc_core.VClients___len__(self)

    def pop(self) -> "std::vector< CClient * >::value_type":
        return _znc_core.VClients_pop(self)

    def __getslice__(self, i: 'std::vector< CClient * >::difference_type', j: 'std::vector< CClient * >::difference_type') -> "std::vector< CClient *,std::allocator< CClient * > > *":
        return _znc_core.VClients___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.VClients___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< CClient * >::difference_type', j: 'std::vector< CClient * >::difference_type') -> "void":
        return _znc_core.VClients___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.VClients___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< CClient * >::value_type":
        return _znc_core.VClients___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.VClients___setitem__(self, *args)

    def append(self, x: 'CClient') -> "void":
        return _znc_core.VClients_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.VClients_empty(self)

    def size(self) -> "std::vector< CClient * >::size_type":
        return _znc_core.VClients_size(self)

    def clear(self) -> "void":
        return _znc_core.VClients_clear(self)

    def swap(self, v: 'VClients') -> "void":
        return _znc_core.VClients_swap(self, v)

    def get_allocator(self) -> "std::vector< CClient * >::allocator_type":
        return _znc_core.VClients_get_allocator(self)

    def begin(self) -> "std::vector< CClient * >::iterator":
        return _znc_core.VClients_begin(self)

    def end(self) -> "std::vector< CClient * >::iterator":
        return _znc_core.VClients_end(self)

    def rbegin(self) -> "std::vector< CClient * >::reverse_iterator":
        return _znc_core.VClients_rbegin(self)

    def rend(self) -> "std::vector< CClient * >::reverse_iterator":
        return _znc_core.VClients_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.VClients_pop_back(self)

    def erase(self, *args) -> "std::vector< CClient * >::iterator":
        return _znc_core.VClients_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_VClients(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'CClient') -> "void":
        return _znc_core.VClients_push_back(self, x)

    def front(self) -> "std::vector< CClient * >::value_type":
        return _znc_core.VClients_front(self)

    def back(self) -> "std::vector< CClient * >::value_type":
        return _znc_core.VClients_back(self)

    def assign(self, n: 'std::vector< CClient * >::size_type', x: 'CClient') -> "void":
        return _znc_core.VClients_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.VClients_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.VClients_insert(self, *args)

    def reserve(self, n: 'std::vector< CClient * >::size_type') -> "void":
        return _znc_core.VClients_reserve(self, n)

    def capacity(self) -> "std::vector< CClient * >::size_type":
        return _znc_core.VClients_capacity(self)
    __swig_destroy__ = _znc_core.delete_VClients
    __del__ = lambda self: None
VClients_swigregister = _znc_core.VClients_swigregister
VClients_swigregister(VClients)


def SetFdCloseOnExec(fd: 'int') -> "void":
    return _znc_core.SetFdCloseOnExec(fd)
SetFdCloseOnExec = _znc_core.SetFdCloseOnExec
class CUtils(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CUtils, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CUtils, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CUtils()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CUtils
    __del__ = lambda self: None
    __swig_getmethods__["GetIP"] = lambda x: _znc_core.CUtils_GetIP
    if _newclass:
        GetIP = staticmethod(_znc_core.CUtils_GetIP)
    __swig_getmethods__["GetLongIP"] = lambda x: _znc_core.CUtils_GetLongIP
    if _newclass:
        GetLongIP = staticmethod(_znc_core.CUtils_GetLongIP)
    __swig_getmethods__["PrintError"] = lambda x: _znc_core.CUtils_PrintError
    if _newclass:
        PrintError = staticmethod(_znc_core.CUtils_PrintError)
    __swig_getmethods__["PrintMessage"] = lambda x: _znc_core.CUtils_PrintMessage
    if _newclass:
        PrintMessage = staticmethod(_znc_core.CUtils_PrintMessage)
    __swig_getmethods__["PrintPrompt"] = lambda x: _znc_core.CUtils_PrintPrompt
    if _newclass:
        PrintPrompt = staticmethod(_znc_core.CUtils_PrintPrompt)
    __swig_getmethods__["PrintAction"] = lambda x: _znc_core.CUtils_PrintAction
    if _newclass:
        PrintAction = staticmethod(_znc_core.CUtils_PrintAction)
    __swig_getmethods__["PrintStatus"] = lambda x: _znc_core.CUtils_PrintStatus
    if _newclass:
        PrintStatus = staticmethod(_znc_core.CUtils_PrintStatus)
    __swig_getmethods__["GetSaltedHashPass"] = lambda x: _znc_core.CUtils_GetSaltedHashPass
    if _newclass:
        GetSaltedHashPass = staticmethod(_znc_core.CUtils_GetSaltedHashPass)
    __swig_getmethods__["GetSalt"] = lambda x: _znc_core.CUtils_GetSalt
    if _newclass:
        GetSalt = staticmethod(_znc_core.CUtils_GetSalt)
    __swig_getmethods__["SaltedMD5Hash"] = lambda x: _znc_core.CUtils_SaltedMD5Hash
    if _newclass:
        SaltedMD5Hash = staticmethod(_znc_core.CUtils_SaltedMD5Hash)
    __swig_getmethods__["SaltedSHA256Hash"] = lambda x: _znc_core.CUtils_SaltedSHA256Hash
    if _newclass:
        SaltedSHA256Hash = staticmethod(_znc_core.CUtils_SaltedSHA256Hash)
    __swig_getmethods__["GetPass"] = lambda x: _znc_core.CUtils_GetPass
    if _newclass:
        GetPass = staticmethod(_znc_core.CUtils_GetPass)
    __swig_getmethods__["GetInput"] = lambda x: _znc_core.CUtils_GetInput
    if _newclass:
        GetInput = staticmethod(_znc_core.CUtils_GetInput)
    __swig_getmethods__["GetBoolInput"] = lambda x: _znc_core.CUtils_GetBoolInput
    if _newclass:
        GetBoolInput = staticmethod(_znc_core.CUtils_GetBoolInput)
    __swig_getmethods__["GetNumInput"] = lambda x: _znc_core.CUtils_GetNumInput
    if _newclass:
        GetNumInput = staticmethod(_znc_core.CUtils_GetNumInput)
    __swig_getmethods__["GetMillTime"] = lambda x: _znc_core.CUtils_GetMillTime
    if _newclass:
        GetMillTime = staticmethod(_znc_core.CUtils_GetMillTime)
    __swig_getmethods__["CTime"] = lambda x: _znc_core.CUtils_CTime
    if _newclass:
        CTime = staticmethod(_znc_core.CUtils_CTime)
    __swig_getmethods__["FormatTime"] = lambda x: _znc_core.CUtils_FormatTime
    if _newclass:
        FormatTime = staticmethod(_znc_core.CUtils_FormatTime)
    __swig_getmethods__["FormatServerTime"] = lambda x: _znc_core.CUtils_FormatServerTime
    if _newclass:
        FormatServerTime = staticmethod(_znc_core.CUtils_FormatServerTime)
    __swig_getmethods__["GetTimezones"] = lambda x: _znc_core.CUtils_GetTimezones
    if _newclass:
        GetTimezones = staticmethod(_znc_core.CUtils_GetTimezones)
    __swig_getmethods__["GetEncodings"] = lambda x: _znc_core.CUtils_GetEncodings
    if _newclass:
        GetEncodings = staticmethod(_znc_core.CUtils_GetEncodings)
    __swig_getmethods__["GetMessageTags"] = lambda x: _znc_core.CUtils_GetMessageTags
    if _newclass:
        GetMessageTags = staticmethod(_znc_core.CUtils_GetMessageTags)
    __swig_getmethods__["SetMessageTags"] = lambda x: _znc_core.CUtils_SetMessageTags
    if _newclass:
        SetMessageTags = staticmethod(_znc_core.CUtils_SetMessageTags)
CUtils_swigregister = _znc_core.CUtils_swigregister
CUtils_swigregister(CUtils)
cvar = _znc_core.cvar
g_HexDigits = cvar.g_HexDigits

def CUtils_GetIP(addr: 'unsigned long') -> "CString":
    return _znc_core.CUtils_GetIP(addr)
CUtils_GetIP = _znc_core.CUtils_GetIP

def CUtils_GetLongIP(sIP: 'CString const &') -> "unsigned long":
    return _znc_core.CUtils_GetLongIP(sIP)
CUtils_GetLongIP = _znc_core.CUtils_GetLongIP

def CUtils_PrintError(sMessage: 'CString const &') -> "void":
    return _znc_core.CUtils_PrintError(sMessage)
CUtils_PrintError = _znc_core.CUtils_PrintError

def CUtils_PrintMessage(sMessage: 'CString const &', bStrong: 'bool'=False) -> "void":
    return _znc_core.CUtils_PrintMessage(sMessage, bStrong)
CUtils_PrintMessage = _znc_core.CUtils_PrintMessage

def CUtils_PrintPrompt(sMessage: 'CString const &') -> "void":
    return _znc_core.CUtils_PrintPrompt(sMessage)
CUtils_PrintPrompt = _znc_core.CUtils_PrintPrompt

def CUtils_PrintAction(sMessage: 'CString const &') -> "void":
    return _znc_core.CUtils_PrintAction(sMessage)
CUtils_PrintAction = _znc_core.CUtils_PrintAction

def CUtils_PrintStatus(*args) -> "void":
    return _znc_core.CUtils_PrintStatus(*args)
CUtils_PrintStatus = _znc_core.CUtils_PrintStatus
CUtils.sDefaultHash = _znc_core.cvar.CUtils_sDefaultHash

def CUtils_GetSaltedHashPass(sSalt: 'CString &') -> "CString":
    return _znc_core.CUtils_GetSaltedHashPass(sSalt)
CUtils_GetSaltedHashPass = _znc_core.CUtils_GetSaltedHashPass

def CUtils_GetSalt() -> "CString":
    return _znc_core.CUtils_GetSalt()
CUtils_GetSalt = _znc_core.CUtils_GetSalt

def CUtils_SaltedMD5Hash(sPass: 'CString const &', sSalt: 'CString const &') -> "CString":
    return _znc_core.CUtils_SaltedMD5Hash(sPass, sSalt)
CUtils_SaltedMD5Hash = _znc_core.CUtils_SaltedMD5Hash

def CUtils_SaltedSHA256Hash(sPass: 'CString const &', sSalt: 'CString const &') -> "CString":
    return _znc_core.CUtils_SaltedSHA256Hash(sPass, sSalt)
CUtils_SaltedSHA256Hash = _znc_core.CUtils_SaltedSHA256Hash

def CUtils_GetPass(sPrompt: 'CString const &') -> "CString":
    return _znc_core.CUtils_GetPass(sPrompt)
CUtils_GetPass = _znc_core.CUtils_GetPass

def CUtils_GetInput(*args) -> "bool":
    return _znc_core.CUtils_GetInput(*args)
CUtils_GetInput = _znc_core.CUtils_GetInput

def CUtils_GetBoolInput(*args) -> "bool":
    return _znc_core.CUtils_GetBoolInput(*args)
CUtils_GetBoolInput = _znc_core.CUtils_GetBoolInput

def CUtils_GetNumInput(*args) -> "bool":
    return _znc_core.CUtils_GetNumInput(*args)
CUtils_GetNumInput = _znc_core.CUtils_GetNumInput

def CUtils_GetMillTime() -> "unsigned long long":
    return _znc_core.CUtils_GetMillTime()
CUtils_GetMillTime = _znc_core.CUtils_GetMillTime

def CUtils_CTime(t: 'time_t', sTZ: 'CString const &') -> "CString":
    return _znc_core.CUtils_CTime(t, sTZ)
CUtils_CTime = _znc_core.CUtils_CTime

def CUtils_FormatTime(t: 'time_t', sFormat: 'CString const &', sTZ: 'CString const &') -> "CString":
    return _znc_core.CUtils_FormatTime(t, sFormat, sTZ)
CUtils_FormatTime = _znc_core.CUtils_FormatTime

def CUtils_FormatServerTime(tv: 'timeval const &') -> "CString":
    return _znc_core.CUtils_FormatServerTime(tv)
CUtils_FormatServerTime = _znc_core.CUtils_FormatServerTime

def CUtils_GetTimezones() -> "SCString":
    return _znc_core.CUtils_GetTimezones()
CUtils_GetTimezones = _znc_core.CUtils_GetTimezones

def CUtils_GetEncodings() -> "SCString":
    return _znc_core.CUtils_GetEncodings()
CUtils_GetEncodings = _znc_core.CUtils_GetEncodings

def CUtils_GetMessageTags(sLine: 'CString const &') -> "MCString":
    return _znc_core.CUtils_GetMessageTags(sLine)
CUtils_GetMessageTags = _znc_core.CUtils_GetMessageTags

def CUtils_SetMessageTags(sLine: 'CString &', mssTags: 'MCString') -> "void":
    return _znc_core.CUtils_SetMessageTags(sLine, mssTags)
CUtils_SetMessageTags = _znc_core.CUtils_SetMessageTags

class CException(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CException, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CException, name)
    __repr__ = _swig_repr
    EX_Shutdown = _znc_core.CException_EX_Shutdown
    EX_Restart = _znc_core.CException_EX_Restart

    def __init__(self, e: 'CException::EType'):
        this = _znc_core.new_CException(e)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CException
    __del__ = lambda self: None

    def GetType(self) -> "CException::EType":
        return _znc_core.CException_GetType(self)
CException_swigregister = _znc_core.CException_swigregister
CException_swigregister(CException)

class CTable(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CTable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CTable, name)
    __repr__ = _swig_repr

    def __init__(self, uPreferredWidth: 'std::vector< std::vector< CString,std::allocator< CString > > >::size_type'=110):
        this = _znc_core.new_CTable(uPreferredWidth)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CTable
    __del__ = lambda self: None

    def AddColumn(self, sName: 'CString const &', bWrappable: 'bool'=True) -> "bool":
        return _znc_core.CTable_AddColumn(self, sName, bWrappable)

    def AddRow(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::size_type":
        return _znc_core.CTable_AddRow(self)

    def SetCell(self, *args) -> "bool":
        return _znc_core.CTable_SetCell(self, *args)

    def GetLine(self, uIdx: 'unsigned int', sLine: 'CString &') -> "bool":
        return _znc_core.CTable_GetLine(self, uIdx, sLine)

    def GetColumnWidth(self, uIdx: 'unsigned int') -> "CString::size_type":
        return _znc_core.CTable_GetColumnWidth(self, uIdx)

    def Clear(self) -> "void":
        return _znc_core.CTable_Clear(self)

    def size(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::size_type":
        return _znc_core.CTable_size(self)

    def empty(self) -> "bool":
        return _znc_core.CTable_empty(self)
CTable_swigregister = _znc_core.CTable_swigregister
CTable_swigregister(CTable)

class CConfigEntry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CConfigEntry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CConfigEntry, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CConfigEntry(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CConfigEntry
    __del__ = lambda self: None
    __swig_setmethods__["m_pSubConfig"] = _znc_core.CConfigEntry_m_pSubConfig_set
    __swig_getmethods__["m_pSubConfig"] = _znc_core.CConfigEntry_m_pSubConfig_get
    if _newclass:
        m_pSubConfig = _swig_property(_znc_core.CConfigEntry_m_pSubConfig_get, _znc_core.CConfigEntry_m_pSubConfig_set)
CConfigEntry_swigregister = _znc_core.CConfigEntry_swigregister
CConfigEntry_swigregister(CConfigEntry)

class CConfig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CConfig, name)
    __repr__ = _swig_repr

    def BeginEntries(self) -> "CConfig::EntryMapIterator":
        return _znc_core.CConfig_BeginEntries(self)

    def EndEntries(self) -> "CConfig::EntryMapIterator":
        return _znc_core.CConfig_EndEntries(self)

    def BeginSubConfigs(self) -> "CConfig::SubConfigMapIterator":
        return _znc_core.CConfig_BeginSubConfigs(self)

    def EndSubConfigs(self) -> "CConfig::SubConfigMapIterator":
        return _znc_core.CConfig_EndSubConfigs(self)

    def AddKeyValuePair(self, sName: 'CString const &', sValue: 'CString const &') -> "void":
        return _znc_core.CConfig_AddKeyValuePair(self, sName, sValue)

    def AddSubConfig(self, sTag: 'CString const &', sName: 'CString const &', Config: 'CConfig') -> "bool":
        return _znc_core.CConfig_AddSubConfig(self, sTag, sName, Config)

    def FindStringVector(self, sName: 'CString const &', vsList: 'VCString', bErase: 'bool'=True) -> "bool":
        return _znc_core.CConfig_FindStringVector(self, sName, vsList, bErase)

    def FindStringEntry(self, *args) -> "bool":
        return _znc_core.CConfig_FindStringEntry(self, *args)

    def FindBoolEntry(self, sName: 'CString const &', bRes: 'bool &', bDefault: 'bool'=False) -> "bool":
        return _znc_core.CConfig_FindBoolEntry(self, sName, bRes, bDefault)

    def FindUIntEntry(self, sName: 'CString const &', uRes: 'unsigned int &', uDefault: 'unsigned int'=0) -> "bool":
        return _znc_core.CConfig_FindUIntEntry(self, sName, uRes, uDefault)

    def FindUShortEntry(self, sName: 'CString const &', uRes: 'unsigned short &', uDefault: 'unsigned short'=0) -> "bool":
        return _znc_core.CConfig_FindUShortEntry(self, sName, uRes, uDefault)

    def FindDoubleEntry(self, sName: 'CString const &', fRes: 'double &', fDefault: 'double'=0) -> "bool":
        return _znc_core.CConfig_FindDoubleEntry(self, sName, fRes, fDefault)

    def FindSubConfig(self, sName: 'CString const &', Config: 'CConfig::SubConfig &', bErase: 'bool'=True) -> "bool":
        return _znc_core.CConfig_FindSubConfig(self, sName, Config, bErase)

    def empty(self) -> "bool":
        return _znc_core.CConfig_empty(self)

    def Parse(self, file: 'CFile', sErrorMsg: 'CString &') -> "bool":
        return _znc_core.CConfig_Parse(self, file, sErrorMsg)

    def Write(self, file: 'CFile', iIndentation: 'unsigned int'=0) -> "void":
        return _znc_core.CConfig_Write(self, file, iIndentation)

    def __init__(self):
        this = _znc_core.new_CConfig()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CConfig
    __del__ = lambda self: None
CConfig_swigregister = _znc_core.CConfig_swigregister
CConfig_swigregister(CConfig)


_znc_core.CS_INVALID_SOCK_swigconstant(_znc_core)
CS_INVALID_SOCK = _znc_core.CS_INVALID_SOCK
class CSCharBuffer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSCharBuffer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSCharBuffer, name)
    __repr__ = _swig_repr

    def __init__(self, iSize: 'size_t'):
        this = _znc_core.new_CSCharBuffer(iSize)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSCharBuffer
    __del__ = lambda self: None

    def __call__(self) -> "char *":
        return _znc_core.CSCharBuffer___call__(self)
CSCharBuffer_swigregister = _znc_core.CSCharBuffer_swigregister
CSCharBuffer_swigregister(CSCharBuffer)

class CSSockAddr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSSockAddr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSSockAddr, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CSSockAddr()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSSockAddr
    __del__ = lambda self: None
    RAF_ANY = _znc_core.CSSockAddr_RAF_ANY
    RAF_INET = _znc_core.CSSockAddr_RAF_INET

    def SinFamily(self) -> "void":
        return _znc_core.CSSockAddr_SinFamily(self)

    def SinPort(self, iPort: 'uint16_t') -> "void":
        return _znc_core.CSSockAddr_SinPort(self, iPort)

    def SetIPv6(self, b: 'bool') -> "void":
        return _znc_core.CSSockAddr_SetIPv6(self, b)

    def GetIPv6(self) -> "bool":
        return _znc_core.CSSockAddr_GetIPv6(self)

    def GetSockAddrLen(self) -> "socklen_t":
        return _znc_core.CSSockAddr_GetSockAddrLen(self)

    def GetSockAddr(self) -> "sockaddr_in *":
        return _znc_core.CSSockAddr_GetSockAddr(self)

    def GetAddr(self) -> "in_addr *":
        return _znc_core.CSSockAddr_GetAddr(self)

    def SetAFRequire(self, iWhich: 'CSSockAddr::EAFRequire') -> "void":
        return _znc_core.CSSockAddr_SetAFRequire(self, iWhich)

    def GetAFRequire(self) -> "CSSockAddr::EAFRequire":
        return _znc_core.CSSockAddr_GetAFRequire(self)
CSSockAddr_swigregister = _znc_core.CSSockAddr_swigregister
CSSockAddr_swigregister(CSSockAddr)

class CGetAddrInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CGetAddrInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CGetAddrInfo, name)
    __repr__ = _swig_repr

    def __init__(self, sHostname: 'CString const &', pSock: 'Csock', csSockAddr: 'CSSockAddr'):
        this = _znc_core.new_CGetAddrInfo(sHostname, pSock, csSockAddr)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CGetAddrInfo
    __del__ = lambda self: None

    def Init(self) -> "void":
        return _znc_core.CGetAddrInfo_Init(self)

    def Process(self) -> "int":
        return _znc_core.CGetAddrInfo_Process(self)

    def Finish(self) -> "int":
        return _znc_core.CGetAddrInfo_Finish(self)
CGetAddrInfo_swigregister = _znc_core.CGetAddrInfo_swigregister
CGetAddrInfo_swigregister(CGetAddrInfo)


def GetAddrInfo(sHostname: 'CString const &', pSock: 'Csock', csSockAddr: 'CSSockAddr') -> "int":
    return _znc_core.GetAddrInfo(sHostname, pSock, csSockAddr)
GetAddrInfo = _znc_core.GetAddrInfo

def GetCsockSSLIdx() -> "int":
    return _znc_core.GetCsockSSLIdx()
GetCsockSSLIdx = _znc_core.GetCsockSSLIdx

def InitCsocket() -> "bool":
    return _znc_core.InitCsocket()
InitCsocket = _znc_core.InitCsocket

def ShutdownCsocket() -> "void":
    return _znc_core.ShutdownCsocket()
ShutdownCsocket = _znc_core.ShutdownCsocket

def GetSockError() -> "int":
    return _znc_core.GetSockError()
GetSockError = _znc_core.GetSockError

def TFD_ZERO(set: 'fd_set *') -> "void":
    return _znc_core.TFD_ZERO(set)
TFD_ZERO = _znc_core.TFD_ZERO

def TFD_SET(iSock: 'cs_sock_t', set: 'fd_set *') -> "void":
    return _znc_core.TFD_SET(iSock, set)
TFD_SET = _znc_core.TFD_SET

def TFD_ISSET(iSock: 'cs_sock_t', set: 'fd_set *') -> "bool":
    return _znc_core.TFD_ISSET(iSock, set)
TFD_ISSET = _znc_core.TFD_ISSET

def TFD_CLR(iSock: 'cs_sock_t', set: 'fd_set *') -> "void":
    return _znc_core.TFD_CLR(iSock, set)
TFD_CLR = _znc_core.TFD_CLR

def __Perror(s: 'CString const &', pszFile: 'char const *', iLineNo: 'uint32_t') -> "void":
    return _znc_core.__Perror(s, pszFile, iLineNo)
__Perror = _znc_core.__Perror

def millitime() -> "uint64_t":
    return _znc_core.millitime()
millitime = _znc_core.millitime
class CCron(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CCron, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CCron, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CCron()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CCron
    __del__ = lambda self: None

    def run(self, tNow: 'timeval &') -> "void":
        return _znc_core.CCron_run(self, tNow)

    def StartMaxCycles(self, *args) -> "void":
        return _znc_core.CCron_StartMaxCycles(self, *args)

    def Start(self, *args) -> "void":
        return _znc_core.CCron_Start(self, *args)

    def Stop(self) -> "void":
        return _znc_core.CCron_Stop(self)

    def Pause(self) -> "void":
        return _znc_core.CCron_Pause(self)

    def UnPause(self) -> "void":
        return _znc_core.CCron_UnPause(self)

    def Reset(self) -> "void":
        return _znc_core.CCron_Reset(self)

    def GetInterval(self) -> "timeval":
        return _znc_core.CCron_GetInterval(self)

    def GetMaxCycles(self) -> "uint32_t":
        return _znc_core.CCron_GetMaxCycles(self)

    def GetCyclesLeft(self) -> "uint32_t":
        return _znc_core.CCron_GetCyclesLeft(self)

    def isValid(self) -> "bool":
        return _znc_core.CCron_isValid(self)

    def GetName(self) -> "CString const &":
        return _znc_core.CCron_GetName(self)

    def SetName(self, sName: 'CString const &') -> "void":
        return _znc_core.CCron_SetName(self, sName)

    def GetNextRun(self) -> "timeval":
        return _znc_core.CCron_GetNextRun(self)

    def RunJob(self) -> "void":
        return _znc_core.CCron_RunJob(self)
CCron_swigregister = _znc_core.CCron_swigregister
CCron_swigregister(CCron)
CS_BLOCKSIZE = cvar.CS_BLOCKSIZE

class CSMonitorFD(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSMonitorFD, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSMonitorFD, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CSMonitorFD()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSMonitorFD
    __del__ = lambda self: None

    def GatherFDsForSelect(self, miiReadyFds: 'std::map< cs_sock_t,short,std::less< cs_sock_t >,std::allocator< std::pair< cs_sock_t const,short > > > &', iTimeoutMS: 'long &') -> "bool":
        return _znc_core.CSMonitorFD_GatherFDsForSelect(self, miiReadyFds, iTimeoutMS)

    def FDsThatTriggered(self, miiReadyFds: 'std::map< cs_sock_t,short,std::less< cs_sock_t >,std::allocator< std::pair< cs_sock_t const,short > > > const &') -> "bool":
        return _znc_core.CSMonitorFD_FDsThatTriggered(self, miiReadyFds)

    def CheckFDs(self, miiReadyFds: 'std::map< cs_sock_t,short,std::less< cs_sock_t >,std::allocator< std::pair< cs_sock_t const,short > > > const &') -> "bool":
        return _znc_core.CSMonitorFD_CheckFDs(self, miiReadyFds)

    def Add(self, iFD: 'cs_sock_t', iMonitorEvents: 'short') -> "void":
        return _znc_core.CSMonitorFD_Add(self, iFD, iMonitorEvents)

    def Remove(self, iFD: 'cs_sock_t') -> "void":
        return _znc_core.CSMonitorFD_Remove(self, iFD)

    def DisableMonitor(self) -> "void":
        return _znc_core.CSMonitorFD_DisableMonitor(self)

    def IsEnabled(self) -> "bool":
        return _znc_core.CSMonitorFD_IsEnabled(self)
CSMonitorFD_swigregister = _znc_core.CSMonitorFD_swigregister
CSMonitorFD_swigregister(CSMonitorFD)

class CSockCommon(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSockCommon, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSockCommon, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CSockCommon()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSockCommon
    __del__ = lambda self: None

    def CleanupCrons(self) -> "void":
        return _znc_core.CSockCommon_CleanupCrons(self)

    def CleanupFDMonitors(self) -> "void":
        return _znc_core.CSockCommon_CleanupFDMonitors(self)

    def GetCrons(self) -> "std::vector< CCron *,std::allocator< CCron * > > const &":
        return _znc_core.CSockCommon_GetCrons(self)

    def Cron(self) -> "void":
        return _znc_core.CSockCommon_Cron(self)

    def AddCron(self, pcCron: 'CCron') -> "void":
        return _znc_core.CSockCommon_AddCron(self, pcCron)

    def DelCron(self, *args) -> "void":
        return _znc_core.CSockCommon_DelCron(self, *args)

    def DelCronByAddr(self, pcCron: 'CCron') -> "void":
        return _znc_core.CSockCommon_DelCronByAddr(self, pcCron)

    def CheckFDs(self, miiReadyFds: 'std::map< cs_sock_t,short,std::less< cs_sock_t >,std::allocator< std::pair< cs_sock_t const,short > > > const &') -> "void":
        return _znc_core.CSockCommon_CheckFDs(self, miiReadyFds)

    def AssignFDs(self, miiReadyFds: 'std::map< cs_sock_t,short,std::less< cs_sock_t >,std::allocator< std::pair< cs_sock_t const,short > > > &', tvtimeout: 'timeval *') -> "void":
        return _znc_core.CSockCommon_AssignFDs(self, miiReadyFds, tvtimeout)

    def MonitorFD(self, pMonitorFD: 'CSMonitorFD') -> "void":
        return _znc_core.CSockCommon_MonitorFD(self, pMonitorFD)
CSockCommon_swigregister = _znc_core.CSockCommon_swigregister
CSockCommon_swigregister(CSockCommon)

class Csock(CSockCommon):
    __swig_setmethods__ = {}
    for _s in [CSockCommon]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Csock, name, value)
    __swig_getmethods__ = {}
    for _s in [CSockCommon]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Csock, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_Csock(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetSockObj(self, sHostname: 'CString const &', iPort: 'uint16_t') -> "Csock *":
        return _znc_core.Csock_GetSockObj(self, sHostname, iPort)
    __swig_destroy__ = _znc_core.delete_Csock
    __del__ = lambda self: None

    def Dereference(self) -> "void":
        return _znc_core.Csock_Dereference(self)

    def Copy(self, cCopy: 'Csock') -> "void":
        return _znc_core.Csock_Copy(self, cCopy)
    OUTBOUND = _znc_core.Csock_OUTBOUND
    LISTENER = _znc_core.Csock_LISTENER
    INBOUND = _znc_core.Csock_INBOUND
    READ_EOF = _znc_core.Csock_READ_EOF
    READ_ERR = _znc_core.Csock_READ_ERR
    READ_EAGAIN = _znc_core.Csock_READ_EAGAIN
    READ_CONNREFUSED = _znc_core.Csock_READ_CONNREFUSED
    READ_TIMEDOUT = _znc_core.Csock_READ_TIMEDOUT
    SEL_OK = _znc_core.Csock_SEL_OK
    SEL_TIMEOUT = _znc_core.Csock_SEL_TIMEOUT
    SEL_EAGAIN = _znc_core.Csock_SEL_EAGAIN
    SEL_ERR = _znc_core.Csock_SEL_ERR
    SSL23 = _znc_core.Csock_SSL23
    SSL2 = _znc_core.Csock_SSL2
    SSL3 = _znc_core.Csock_SSL3
    TLS1 = _znc_core.Csock_TLS1
    TLS11 = _znc_core.Csock_TLS11
    TLS12 = _znc_core.Csock_TLS12
    EDP_None = _znc_core.Csock_EDP_None
    EDP_SSLv2 = _znc_core.Csock_EDP_SSLv2
    EDP_SSLv3 = _znc_core.Csock_EDP_SSLv3
    EDP_TLSv1 = _znc_core.Csock_EDP_TLSv1
    EDP_TLSv1_1 = _znc_core.Csock_EDP_TLSv1_1
    EDP_TLSv1_2 = _znc_core.Csock_EDP_TLSv1_2
    EDP_SSL = _znc_core.Csock_EDP_SSL
    CST_START = _znc_core.Csock_CST_START
    CST_DNS = _znc_core.Csock_CST_DNS
    CST_BINDVHOST = _znc_core.Csock_CST_BINDVHOST
    CST_DESTDNS = _znc_core.Csock_CST_DESTDNS
    CST_CONNECT = _znc_core.Csock_CST_CONNECT
    CST_CONNECTSSL = _znc_core.Csock_CST_CONNECTSSL
    CST_OK = _znc_core.Csock_CST_OK
    CLT_DONT = _znc_core.Csock_CLT_DONT
    CLT_NOW = _znc_core.Csock_CLT_NOW
    CLT_AFTERWRITE = _znc_core.Csock_CLT_AFTERWRITE
    CLT_DEREFERENCE = _znc_core.Csock_CLT_DEREFERENCE

    def __lshift__(self, *args) -> "Csock &":
        return _znc_core.Csock___lshift__(self, *args)

    def Connect(self) -> "bool":
        return _znc_core.Csock_Connect(self)

    def Listen(self, *args) -> "bool":
        return _znc_core.Csock_Listen(self, *args)

    def Accept(self, sHost: 'CString &', iRPort: 'uint16_t &') -> "cs_sock_t":
        return _znc_core.Csock_Accept(self, sHost, iRPort)

    def AcceptSSL(self) -> "bool":
        return _znc_core.Csock_AcceptSSL(self)

    def SSLClientSetup(self) -> "bool":
        return _znc_core.Csock_SSLClientSetup(self)

    def SSLServerSetup(self) -> "bool":
        return _znc_core.Csock_SSLServerSetup(self)

    def ConnectSSL(self) -> "bool":
        return _znc_core.Csock_ConnectSSL(self)

    def StartTLS(self) -> "bool":
        return _znc_core.Csock_StartTLS(self)

    def Write(self, *args) -> "bool":
        return _znc_core.Csock_Write(self, *args)

    def Read(self, data: 'char *', len: 'size_t') -> "cs_ssize_t":
        return _znc_core.Csock_Read(self, data, len)

    def GetLocalIP(self) -> "CString":
        return _znc_core.Csock_GetLocalIP(self)

    def GetRemoteIP(self) -> "CString":
        return _znc_core.Csock_GetRemoteIP(self)

    def IsConnected(self) -> "bool":
        return _znc_core.Csock_IsConnected(self)

    def SetIsConnected(self, b: 'bool') -> "void":
        return _znc_core.Csock_SetIsConnected(self, b)

    def GetRSock(self, *args) -> "cs_sock_t const &":
        return _znc_core.Csock_GetRSock(self, *args)

    def SetRSock(self, iSock: 'cs_sock_t') -> "void":
        return _znc_core.Csock_SetRSock(self, iSock)

    def GetWSock(self, *args) -> "cs_sock_t const &":
        return _znc_core.Csock_GetWSock(self, *args)

    def SetWSock(self, iSock: 'cs_sock_t') -> "void":
        return _znc_core.Csock_SetWSock(self, iSock)

    def SetSock(self, iSock: 'cs_sock_t') -> "void":
        return _znc_core.Csock_SetSock(self, iSock)

    def GetSock(self, *args) -> "cs_sock_t const &":
        return _znc_core.Csock_GetSock(self, *args)

    def CallSockError(self, *args) -> "void":
        return _znc_core.Csock_CallSockError(self, *args)

    def ResetTimer(self) -> "void":
        return _znc_core.Csock_ResetTimer(self)

    def PauseRead(self) -> "void":
        return _znc_core.Csock_PauseRead(self)

    def UnPauseRead(self) -> "void":
        return _znc_core.Csock_UnPauseRead(self)

    def IsReadPaused(self) -> "bool":
        return _znc_core.Csock_IsReadPaused(self)
    TMO_READ = _znc_core.Csock_TMO_READ
    TMO_WRITE = _znc_core.Csock_TMO_WRITE
    TMO_ACCEPT = _znc_core.Csock_TMO_ACCEPT
    TMO_ALL = _znc_core.Csock_TMO_ALL

    def SetTimeout(self, *args) -> "void":
        return _znc_core.Csock_SetTimeout(self, *args)

    def SetTimeoutType(self, iTimeoutType: 'uint32_t') -> "void":
        return _znc_core.Csock_SetTimeoutType(self, iTimeoutType)

    def GetTimeout(self) -> "int":
        return _znc_core.Csock_GetTimeout(self)

    def GetTimeoutType(self) -> "uint32_t":
        return _znc_core.Csock_GetTimeoutType(self)

    def CheckTimeout(self, iNow: 'time_t') -> "bool":
        return _znc_core.Csock_CheckTimeout(self, iNow)

    def PushBuff(self, data: 'char const *', len: 'size_t', bStartAtZero: 'bool'=False) -> "void":
        return _znc_core.Csock_PushBuff(self, data, len, bStartAtZero)

    def GetInternalReadBuffer(self) -> "CString &":
        return _znc_core.Csock_GetInternalReadBuffer(self)

    def GetInternalWriteBuffer(self) -> "CString &":
        return _znc_core.Csock_GetInternalWriteBuffer(self)

    def SetMaxBufferThreshold(self, iThreshold: 'uint32_t') -> "void":
        return _znc_core.Csock_SetMaxBufferThreshold(self, iThreshold)

    def GetMaxBufferThreshold(self) -> "uint32_t":
        return _znc_core.Csock_GetMaxBufferThreshold(self)

    def GetType(self) -> "int":
        return _znc_core.Csock_GetType(self)

    def SetType(self, iType: 'int') -> "void":
        return _znc_core.Csock_SetType(self, iType)

    def GetSockName(self) -> "CString const &":
        return _znc_core.Csock_GetSockName(self)

    def SetSockName(self, sName: 'CString const &') -> "void":
        return _znc_core.Csock_SetSockName(self, sName)

    def GetHostName(self) -> "CString const &":
        return _znc_core.Csock_GetHostName(self)

    def SetHostName(self, sHostname: 'CString const &') -> "void":
        return _znc_core.Csock_SetHostName(self, sHostname)

    def GetStartTime(self) -> "uint64_t":
        return _znc_core.Csock_GetStartTime(self)

    def ResetStartTime(self) -> "void":
        return _znc_core.Csock_ResetStartTime(self)

    def GetBytesRead(self) -> "uint64_t":
        return _znc_core.Csock_GetBytesRead(self)

    def ResetBytesRead(self) -> "void":
        return _znc_core.Csock_ResetBytesRead(self)

    def GetBytesWritten(self) -> "uint64_t":
        return _znc_core.Csock_GetBytesWritten(self)

    def ResetBytesWritten(self) -> "void":
        return _znc_core.Csock_ResetBytesWritten(self)

    def GetAvgRead(self, iSample: 'uint64_t'=1000) -> "double":
        return _znc_core.Csock_GetAvgRead(self, iSample)

    def GetAvgWrite(self, iSample: 'uint64_t'=1000) -> "double":
        return _znc_core.Csock_GetAvgWrite(self, iSample)

    def GetRemotePort(self) -> "uint16_t":
        return _znc_core.Csock_GetRemotePort(self)

    def GetLocalPort(self) -> "uint16_t":
        return _znc_core.Csock_GetLocalPort(self)

    def GetPort(self) -> "uint16_t":
        return _znc_core.Csock_GetPort(self)

    def SetPort(self, iPort: 'uint16_t') -> "void":
        return _znc_core.Csock_SetPort(self, iPort)

    def Close(self, *args) -> "void":
        return _znc_core.Csock_Close(self, *args)

    def GetCloseType(self) -> "Csock::ECloseType":
        return _znc_core.Csock_GetCloseType(self)

    def IsClosed(self) -> "bool":
        return _znc_core.Csock_IsClosed(self)

    def NonBlockingIO(self) -> "void":
        return _znc_core.Csock_NonBlockingIO(self)

    def GetSSL(self) -> "bool":
        return _znc_core.Csock_GetSSL(self)

    def SetSSL(self, b: 'bool') -> "void":
        return _znc_core.Csock_SetSSL(self, b)

    def HasWriteBuffer(self) -> "bool":
        return _znc_core.Csock_HasWriteBuffer(self)

    def ClearWriteBuffer(self) -> "void":
        return _znc_core.Csock_ClearWriteBuffer(self)

    def SslIsEstablished(self) -> "bool":
        return _znc_core.Csock_SslIsEstablished(self)

    def ConnectInetd(self, *args) -> "bool":
        return _znc_core.Csock_ConnectInetd(self, *args)

    def ConnectFD(self, *args) -> "bool":
        return _znc_core.Csock_ConnectFD(self, *args)

    def SetParentSockName(self, sParentName: 'CString const &') -> "void":
        return _znc_core.Csock_SetParentSockName(self, sParentName)

    def GetParentSockName(self) -> "CString const &":
        return _znc_core.Csock_GetParentSockName(self)

    def SetRate(self, iBytes: 'uint32_t', iMilliseconds: 'uint64_t') -> "void":
        return _znc_core.Csock_SetRate(self, iBytes, iMilliseconds)

    def GetRateBytes(self) -> "uint32_t":
        return _znc_core.Csock_GetRateBytes(self)

    def GetRateTime(self) -> "uint64_t":
        return _znc_core.Csock_GetRateTime(self)

    def Connected(self) -> "void":
        return _znc_core.Csock_Connected(self)

    def Disconnected(self) -> "void":
        return _znc_core.Csock_Disconnected(self)

    def Timeout(self) -> "void":
        return _znc_core.Csock_Timeout(self)

    def ReadData(self, data: 'char const *', len: 'size_t') -> "void":
        return _znc_core.Csock_ReadData(self, data, len)

    def ReadLine(self, sLine: 'CString const &') -> "void":
        return _znc_core.Csock_ReadLine(self, sLine)

    def EnableReadLine(self) -> "void":
        return _znc_core.Csock_EnableReadLine(self)

    def DisableReadLine(self) -> "void":
        return _znc_core.Csock_DisableReadLine(self)

    def HasReadLine(self) -> "bool":
        return _znc_core.Csock_HasReadLine(self)

    def ReachedMaxBuffer(self) -> "void":
        return _znc_core.Csock_ReachedMaxBuffer(self)

    def SockError(self, iErrno: 'int', sDescription: 'CString const &') -> "void":
        return _znc_core.Csock_SockError(self, iErrno, sDescription)

    def ConnectionFrom(self, sHost: 'CString const &', iPort: 'uint16_t') -> "bool":
        return _znc_core.Csock_ConnectionFrom(self, sHost, iPort)

    def Listening(self, sBindIP: 'CString const &', uPort: 'uint16_t') -> "void":
        return _znc_core.Csock_Listening(self, sBindIP, uPort)

    def ConnectionRefused(self) -> "void":
        return _znc_core.Csock_ConnectionRefused(self)

    def ReadPaused(self) -> "void":
        return _znc_core.Csock_ReadPaused(self)

    def GetTimeSinceLastDataTransaction(self, iNow: 'time_t'=0) -> "time_t":
        return _znc_core.Csock_GetTimeSinceLastDataTransaction(self, iNow)

    def GetLastCheckTimeout(self) -> "time_t":
        return _znc_core.Csock_GetLastCheckTimeout(self)

    def GetNextCheckTimeout(self, iNow: 'time_t'=0) -> "time_t":
        return _znc_core.Csock_GetNextCheckTimeout(self, iNow)

    def GetPending(self) -> "int":
        return _znc_core.Csock_GetPending(self)

    def GetConState(self) -> "Csock::ECONState":
        return _znc_core.Csock_GetConState(self)

    def SetConState(self, eState: 'Csock::ECONState') -> "void":
        return _znc_core.Csock_SetConState(self, eState)

    def CreateSocksFD(self) -> "bool":
        return _znc_core.Csock_CreateSocksFD(self)

    def CloseSocksFD(self) -> "void":
        return _znc_core.Csock_CloseSocksFD(self)

    def GetBindHost(self) -> "CString const &":
        return _znc_core.Csock_GetBindHost(self)

    def SetBindHost(self, sBindHost: 'CString const &') -> "void":
        return _znc_core.Csock_SetBindHost(self, sBindHost)
    DNS_VHOST = _znc_core.Csock_DNS_VHOST
    DNS_DEST = _znc_core.Csock_DNS_DEST

    def DNSLookup(self, eDNSLType: 'Csock::EDNSLType') -> "int":
        return _znc_core.Csock_DNSLookup(self, eDNSLType)

    def SetupVHost(self) -> "bool":
        return _znc_core.Csock_SetupVHost(self)

    def GetIPv6(self) -> "bool":
        return _znc_core.Csock_GetIPv6(self)

    def SetIPv6(self, b: 'bool') -> "void":
        return _znc_core.Csock_SetIPv6(self, b)

    def SetAFRequire(self, iAFRequire: 'CSSockAddr::EAFRequire') -> "void":
        return _znc_core.Csock_SetAFRequire(self, iAFRequire)

    def AllowWrite(self, iNOW: 'uint64_t &') -> "bool":
        return _znc_core.Csock_AllowWrite(self, iNOW)

    def SetSkipConnect(self, b: 'bool') -> "void":
        return _znc_core.Csock_SetSkipConnect(self, b)

    def GetAddrInfo(self, sHostname: 'CString const &', csSockAddr: 'CSSockAddr') -> "int":
        return _znc_core.Csock_GetAddrInfo(self, sHostname, csSockAddr)

    def ConvertAddress(self, pAddr: 'sockaddr_storage const *', iAddrLen: 'socklen_t', sIP: 'CString &', piPort: 'uint16_t *') -> "int":
        return _znc_core.Csock_ConvertAddress(self, pAddr, iAddrLen, sIP, piPort)

    def GetMaxConns(self) -> "int":
        return _znc_core.Csock_GetMaxConns(self)

    def WriteBytes(self, data: 'PyObject *') -> "PyObject *":
        return _znc_core.Csock_WriteBytes(self, data)
Csock_swigregister = _znc_core.Csock_swigregister
Csock_swigregister(Csock)

class CSConnection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSConnection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSConnection, name)
    __repr__ = _swig_repr

    def __init__(self, sHostname: 'CString const &', iPort: 'uint16_t', iTimeout: 'int'=60):
        this = _znc_core.new_CSConnection(sHostname, iPort, iTimeout)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSConnection
    __del__ = lambda self: None

    def GetHostname(self) -> "CString const &":
        return _znc_core.CSConnection_GetHostname(self)

    def GetSockName(self) -> "CString const &":
        return _znc_core.CSConnection_GetSockName(self)

    def GetBindHost(self) -> "CString const &":
        return _znc_core.CSConnection_GetBindHost(self)

    def GetPort(self) -> "uint16_t":
        return _znc_core.CSConnection_GetPort(self)

    def GetTimeout(self) -> "int":
        return _znc_core.CSConnection_GetTimeout(self)

    def GetIsSSL(self) -> "bool":
        return _znc_core.CSConnection_GetIsSSL(self)

    def GetAFRequire(self) -> "CSSockAddr::EAFRequire":
        return _znc_core.CSConnection_GetAFRequire(self)

    def SetHostname(self, s: 'CString const &') -> "void":
        return _znc_core.CSConnection_SetHostname(self, s)

    def SetSockName(self, s: 'CString const &') -> "void":
        return _znc_core.CSConnection_SetSockName(self, s)

    def SetBindHost(self, s: 'CString const &') -> "void":
        return _znc_core.CSConnection_SetBindHost(self, s)

    def SetPort(self, i: 'uint16_t') -> "void":
        return _znc_core.CSConnection_SetPort(self, i)

    def SetTimeout(self, i: 'int') -> "void":
        return _znc_core.CSConnection_SetTimeout(self, i)

    def SetIsSSL(self, b: 'bool') -> "void":
        return _znc_core.CSConnection_SetIsSSL(self, b)

    def SetAFRequire(self, iAFRequire: 'CSSockAddr::EAFRequire') -> "void":
        return _znc_core.CSConnection_SetAFRequire(self, iAFRequire)
CSConnection_swigregister = _znc_core.CSConnection_swigregister
CSConnection_swigregister(CSConnection)

class CSSSLConnection(CSConnection):
    __swig_setmethods__ = {}
    for _s in [CSConnection]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSSSLConnection, name, value)
    __swig_getmethods__ = {}
    for _s in [CSConnection]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CSSSLConnection, name)
    __repr__ = _swig_repr

    def __init__(self, sHostname: 'CString const &', iPort: 'uint16_t', iTimeout: 'int'=60):
        this = _znc_core.new_CSSSLConnection(sHostname, iPort, iTimeout)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSSSLConnection
    __del__ = lambda self: None
CSSSLConnection_swigregister = _znc_core.CSSSLConnection_swigregister
CSSSLConnection_swigregister(CSSSLConnection)

class CSListener(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSListener, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CSListener(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSListener
    __del__ = lambda self: None

    def SetDetach(self, b: 'bool') -> "void":
        return _znc_core.CSListener_SetDetach(self, b)

    def GetDetach(self) -> "bool":
        return _znc_core.CSListener_GetDetach(self)

    def GetPort(self) -> "uint16_t":
        return _znc_core.CSListener_GetPort(self)

    def GetSockName(self) -> "CString const &":
        return _znc_core.CSListener_GetSockName(self)

    def GetBindHost(self) -> "CString const &":
        return _znc_core.CSListener_GetBindHost(self)

    def GetIsSSL(self) -> "bool":
        return _znc_core.CSListener_GetIsSSL(self)

    def GetMaxConns(self) -> "int":
        return _znc_core.CSListener_GetMaxConns(self)

    def GetTimeout(self) -> "uint32_t":
        return _znc_core.CSListener_GetTimeout(self)

    def GetAFRequire(self) -> "CSSockAddr::EAFRequire":
        return _znc_core.CSListener_GetAFRequire(self)

    def SetPort(self, iPort: 'uint16_t') -> "void":
        return _znc_core.CSListener_SetPort(self, iPort)

    def SetSockName(self, sSockName: 'CString const &') -> "void":
        return _znc_core.CSListener_SetSockName(self, sSockName)

    def SetBindHost(self, sBindHost: 'CString const &') -> "void":
        return _znc_core.CSListener_SetBindHost(self, sBindHost)

    def SetIsSSL(self, b: 'bool') -> "void":
        return _znc_core.CSListener_SetIsSSL(self, b)

    def SetMaxConns(self, i: 'int') -> "void":
        return _znc_core.CSListener_SetMaxConns(self, i)

    def SetTimeout(self, i: 'uint32_t') -> "void":
        return _znc_core.CSListener_SetTimeout(self, i)

    def SetAFRequire(self, iAFRequire: 'CSSockAddr::EAFRequire') -> "void":
        return _znc_core.CSListener_SetAFRequire(self, iAFRequire)
CSListener_swigregister = _znc_core.CSListener_swigregister
CSListener_swigregister(CSListener)

class CSocketManager(CSockCommon):
    __swig_setmethods__ = {}
    for _s in [CSockCommon]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSocketManager, name, value)
    __swig_getmethods__ = {}
    for _s in [CSockCommon]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CSocketManager, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CSocketManager()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSocketManager
    __del__ = lambda self: None

    def clear(self) -> "void":
        return _znc_core.CSocketManager_clear(self)

    def Cleanup(self) -> "void":
        return _znc_core.CSocketManager_Cleanup(self)

    def GetSockObj(self, sHostname: 'CString const &', uPort: 'uint16_t', iTimeout: 'int'=60) -> "Csock *":
        return _znc_core.CSocketManager_GetSockObj(self, sHostname, uPort, iTimeout)
    SUCCESS = _znc_core.CSocketManager_SUCCESS
    SELECT_ERROR = _znc_core.CSocketManager_SELECT_ERROR
    SELECT_TIMEOUT = _znc_core.CSocketManager_SELECT_TIMEOUT
    SELECT_TRYAGAIN = _znc_core.CSocketManager_SELECT_TRYAGAIN

    def Connect(self, cCon: 'CSConnection', pcSock: 'Csock'=None) -> "void":
        return _znc_core.CSocketManager_Connect(self, cCon, pcSock)

    def Listen(self, cListen: 'CSListener', pcSock: 'Csock'=None, piRandPort: 'uint16_t *'=None) -> "bool":
        return _znc_core.CSocketManager_Listen(self, cListen, pcSock, piRandPort)

    def HasFDs(self) -> "bool":
        return _znc_core.CSocketManager_HasFDs(self)

    def Loop(self) -> "void":
        return _znc_core.CSocketManager_Loop(self)

    def DynamicSelectLoop(self, iLowerBounds: 'uint64_t', iUpperBounds: 'uint64_t', iMaxResolution: 'time_t'=3600) -> "void":
        return _znc_core.CSocketManager_DynamicSelectLoop(self, iLowerBounds, iUpperBounds, iMaxResolution)

    def AddSock(self, pcSock: 'Csock', sSockName: 'CString const &') -> "void":
        return _znc_core.CSocketManager_AddSock(self, pcSock, sSockName)

    def FindSockByRemotePort(self, iPort: 'uint16_t') -> "Csock *":
        return _znc_core.CSocketManager_FindSockByRemotePort(self, iPort)

    def FindSockByLocalPort(self, iPort: 'uint16_t') -> "Csock *":
        return _znc_core.CSocketManager_FindSockByLocalPort(self, iPort)

    def FindSockByName(self, sName: 'CString const &') -> "Csock *":
        return _znc_core.CSocketManager_FindSockByName(self, sName)

    def FindSockByFD(self, iFD: 'cs_sock_t') -> "Csock *":
        return _znc_core.CSocketManager_FindSockByFD(self, iFD)

    def FindSocksByName(self, sName: 'CString const &') -> "std::vector< Csock *,std::allocator< Csock * > >":
        return _znc_core.CSocketManager_FindSocksByName(self, sName)

    def FindSocksByRemoteHost(self, sHostname: 'CString const &') -> "std::vector< Csock *,std::allocator< Csock * > >":
        return _znc_core.CSocketManager_FindSocksByRemoteHost(self, sHostname)

    def GetErrno(self) -> "int":
        return _znc_core.CSocketManager_GetErrno(self)

    def GetSelectTimeout(self) -> "uint64_t":
        return _znc_core.CSocketManager_GetSelectTimeout(self)

    def SetSelectTimeout(self, iTimeout: 'uint64_t') -> "void":
        return _znc_core.CSocketManager_SetSelectTimeout(self, iTimeout)

    def DelSockByAddr(self, pcSock: 'Csock') -> "void":
        return _znc_core.CSocketManager_DelSockByAddr(self, pcSock)

    def DelSock(self, iPos: 'size_t') -> "void":
        return _znc_core.CSocketManager_DelSock(self, iPos)

    def SwapSockByIdx(self, pNewSock: 'Csock', iOrginalSockIdx: 'size_t') -> "bool":
        return _znc_core.CSocketManager_SwapSockByIdx(self, pNewSock, iOrginalSockIdx)

    def SwapSockByAddr(self, pNewSock: 'Csock', pOrigSock: 'Csock') -> "bool":
        return _znc_core.CSocketManager_SwapSockByAddr(self, pNewSock, pOrigSock)

    def GetBytesRead(self) -> "uint64_t":
        return _znc_core.CSocketManager_GetBytesRead(self)

    def GetBytesWritten(self) -> "uint64_t":
        return _znc_core.CSocketManager_GetBytesWritten(self)
    ECT_Read = _znc_core.CSocketManager_ECT_Read
    ECT_Write = _znc_core.CSocketManager_ECT_Write

    def FDSetCheck(self, iFd: 'cs_sock_t', miiReadyFds: 'std::map< cs_sock_t,short,std::less< cs_sock_t >,std::allocator< std::pair< cs_sock_t const,short > > > &', eType: 'CSocketManager::ECheckType') -> "void":
        return _znc_core.CSocketManager_FDSetCheck(self, iFd, miiReadyFds, eType)

    def FDHasCheck(self, iFd: 'cs_sock_t', miiReadyFds: 'std::map< cs_sock_t,short,std::less< cs_sock_t >,std::allocator< std::pair< cs_sock_t const,short > > > &', eType: 'CSocketManager::ECheckType') -> "bool":
        return _znc_core.CSocketManager_FDHasCheck(self, iFd, miiReadyFds, eType)
CSocketManager_swigregister = _znc_core.CSocketManager_swigregister
CSocketManager_swigregister(CSocketManager)

class ZNCSocketManager(CSocketManager):
    __swig_setmethods__ = {}
    for _s in [CSocketManager]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ZNCSocketManager, name, value)
    __swig_getmethods__ = {}
    for _s in [CSocketManager]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ZNCSocketManager, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_ZNCSocketManager()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_ZNCSocketManager
    __del__ = lambda self: None

    def GetSockObj(self, sHostname: 'CString const &', uPort: 'uint16_t', iTimeout: 'int'=60) -> "CZNCSock *":
        return _znc_core.ZNCSocketManager_GetSockObj(self, sHostname, uPort, iTimeout)
ZNCSocketManager_swigregister = _znc_core.ZNCSocketManager_swigregister
ZNCSocketManager_swigregister(ZNCSocketManager)

class CZNCSock(Csock):
    __swig_setmethods__ = {}
    for _s in [Csock]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CZNCSock, name, value)
    __swig_getmethods__ = {}
    for _s in [Csock]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CZNCSock, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CZNCSock(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CZNCSock
    __del__ = lambda self: None

    def ConvertAddress(self, pAddr: 'sockaddr_storage const *', iAddrLen: 'socklen_t', sIP: 'CString &', piPort: 'unsigned short *') -> "int":
        return _znc_core.CZNCSock_ConvertAddress(self, pAddr, iAddrLen, sIP, piPort)

    def SetHostToVerifySSL(self, sHost: 'CString const &') -> "void":
        return _znc_core.CZNCSock_SetHostToVerifySSL(self, sHost)

    def GetSSLPeerFingerprint(self) -> "CString":
        return _znc_core.CZNCSock_GetSSLPeerFingerprint(self)

    def SetSSLTrustedPeerFingerprints(self, ssFPs: 'SCString') -> "void":
        return _znc_core.CZNCSock_SetSSLTrustedPeerFingerprints(self, ssFPs)

    def SetEncoding(self, arg2: 'CString const &') -> "void":
        return _znc_core.CZNCSock_SetEncoding(self, arg2)

    def GetRemoteIP(self) -> "CString":
        return _znc_core.CZNCSock_GetRemoteIP(self)
CZNCSock_swigregister = _znc_core.CZNCSock_swigregister
CZNCSock_swigregister(CZNCSock)


_znc_core.ADDR_IPV4ONLY_swigconstant(_znc_core)
ADDR_IPV4ONLY = _znc_core.ADDR_IPV4ONLY

_znc_core.ADDR_IPV6ONLY_swigconstant(_znc_core)
ADDR_IPV6ONLY = _znc_core.ADDR_IPV6ONLY

_znc_core.ADDR_ALL_swigconstant(_znc_core)
ADDR_ALL = _znc_core.ADDR_ALL
class CSockManager(ZNCSocketManager):
    __swig_setmethods__ = {}
    for _s in [ZNCSocketManager]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSockManager, name, value)
    __swig_getmethods__ = {}
    for _s in [ZNCSocketManager]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CSockManager, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CSockManager()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSockManager
    __del__ = lambda self: None

    def ListenHost(self, *args) -> "bool":
        return _znc_core.CSockManager_ListenHost(self, *args)

    def ListenAll(self, *args) -> "bool":
        return _znc_core.CSockManager_ListenAll(self, *args)

    def ListenRand(self, *args) -> "unsigned short":
        return _znc_core.CSockManager_ListenRand(self, *args)

    def ListenAllRand(self, *args) -> "unsigned short":
        return _znc_core.CSockManager_ListenAllRand(self, *args)

    def Connect(self, *args) -> "void":
        return _znc_core.CSockManager_Connect(self, *args)

    def GetAnonConnectionCount(self, sIP: 'CString const &') -> "unsigned int":
        return _znc_core.CSockManager_GetAnonConnectionCount(self, sIP)

    def DelSockByAddr(self, pcSock: 'Csock') -> "void":
        return _znc_core.CSockManager_DelSockByAddr(self, pcSock)
CSockManager_swigregister = _znc_core.CSockManager_swigregister
CSockManager_swigregister(CSockManager)

class CSocket(CZNCSock):
    __swig_setmethods__ = {}
    for _s in [CZNCSock]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSocket, name, value)
    __swig_getmethods__ = {}
    for _s in [CZNCSock]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CSocket, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CSocket(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CSocket
    __del__ = lambda self: None

    def ReachedMaxBuffer(self) -> "void":
        return _znc_core.CSocket_ReachedMaxBuffer(self)

    def SockError(self, iErrno: 'int', sDescription: 'CString const &') -> "void":
        return _znc_core.CSocket_SockError(self, iErrno, sDescription)

    def ConnectionFrom(self, sHost: 'CString const &', uPort: 'unsigned short') -> "bool":
        return _znc_core.CSocket_ConnectionFrom(self, sHost, uPort)

    def Connect(self, *args) -> "bool":
        return _znc_core.CSocket_Connect(self, *args)

    def Listen(self, *args) -> "bool":
        return _znc_core.CSocket_Listen(self, *args)

    def GetModule(self) -> "CModule *":
        return _znc_core.CSocket_GetModule(self)
CSocket_swigregister = _znc_core.CSocket_swigregister
CSocket_swigregister(CSocket)

class CIRCSocket(CZNCSock):
    __swig_setmethods__ = {}
    for _s in [CZNCSock]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CIRCSocket, name, value)
    __swig_getmethods__ = {}
    for _s in [CZNCSock]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CIRCSocket, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CIRCSocket()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CIRCSocket
    __del__ = lambda self: None
CIRCSocket_swigregister = _znc_core.CIRCSocket_swigregister
CIRCSocket_swigregister(CIRCSocket)

class CFile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CFile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CFile, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CFile(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CFile
    __del__ = lambda self: None
    FT_REGULAR = _znc_core.CFile_FT_REGULAR
    FT_DIRECTORY = _znc_core.CFile_FT_DIRECTORY
    FT_CHARACTER = _znc_core.CFile_FT_CHARACTER
    FT_BLOCK = _znc_core.CFile_FT_BLOCK
    FT_FIFO = _znc_core.CFile_FT_FIFO
    FT_LINK = _znc_core.CFile_FT_LINK
    FT_SOCK = _znc_core.CFile_FT_SOCK

    def SetFileName(self, sLongName: 'CString const &') -> "void":
        return _znc_core.CFile_SetFileName(self, sLongName)

    def IsReg(self, *args) -> "bool":
        return _znc_core.CFile_IsReg(self, *args)

    def IsDir(self, *args) -> "bool":
        return _znc_core.CFile_IsDir(self, *args)

    def IsChr(self, *args) -> "bool":
        return _znc_core.CFile_IsChr(self, *args)

    def IsBlk(self, *args) -> "bool":
        return _znc_core.CFile_IsBlk(self, *args)

    def IsFifo(self, *args) -> "bool":
        return _znc_core.CFile_IsFifo(self, *args)

    def IsLnk(self, *args) -> "bool":
        return _znc_core.CFile_IsLnk(self, *args)

    def IsSock(self, *args) -> "bool":
        return _znc_core.CFile_IsSock(self, *args)
    __swig_getmethods__["FType"] = lambda x: _znc_core.CFile_FType
    if _newclass:
        FType = staticmethod(_znc_core.CFile_FType)
    FA_Name = _znc_core.CFile_FA_Name
    FA_Size = _znc_core.CFile_FA_Size
    FA_ATime = _znc_core.CFile_FA_ATime
    FA_MTime = _znc_core.CFile_FA_MTime
    FA_CTime = _znc_core.CFile_FA_CTime
    FA_UID = _znc_core.CFile_FA_UID
    __swig_getmethods__["Exists"] = lambda x: _znc_core.CFile_Exists
    if _newclass:
        Exists = staticmethod(_znc_core.CFile_Exists)
    __swig_getmethods__["GetSize"] = lambda x: _znc_core.CFile_GetSize
    if _newclass:
        GetSize = staticmethod(_znc_core.CFile_GetSize)
    __swig_getmethods__["GetATime"] = lambda x: _znc_core.CFile_GetATime
    if _newclass:
        GetATime = staticmethod(_znc_core.CFile_GetATime)
    __swig_getmethods__["GetMTime"] = lambda x: _znc_core.CFile_GetMTime
    if _newclass:
        GetMTime = staticmethod(_znc_core.CFile_GetMTime)
    __swig_getmethods__["GetCTime"] = lambda x: _znc_core.CFile_GetCTime
    if _newclass:
        GetCTime = staticmethod(_znc_core.CFile_GetCTime)
    __swig_getmethods__["GetUID"] = lambda x: _znc_core.CFile_GetUID
    if _newclass:
        GetUID = staticmethod(_znc_core.CFile_GetUID)
    __swig_getmethods__["GetGID"] = lambda x: _znc_core.CFile_GetGID
    if _newclass:
        GetGID = staticmethod(_znc_core.CFile_GetGID)
    __swig_getmethods__["GetInfo"] = lambda x: _znc_core.CFile_GetInfo
    if _newclass:
        GetInfo = staticmethod(_znc_core.CFile_GetInfo)
    __swig_getmethods__["Delete"] = lambda x: _znc_core.CFile_Delete
    if _newclass:
        Delete = staticmethod(_znc_core.CFile_Delete)
    __swig_getmethods__["Move"] = lambda x: _znc_core.CFile_Move
    if _newclass:
        Move = staticmethod(_znc_core.CFile_Move)
    __swig_getmethods__["Copy"] = lambda x: _znc_core.CFile_Copy
    if _newclass:
        Copy = staticmethod(_znc_core.CFile_Copy)
    __swig_getmethods__["Chmod"] = lambda x: _znc_core.CFile_Chmod
    if _newclass:
        Chmod = staticmethod(_znc_core.CFile_Chmod)

    def Seek(self, uPos: 'off_t') -> "bool":
        return _znc_core.CFile_Seek(self, uPos)

    def Truncate(self) -> "bool":
        return _znc_core.CFile_Truncate(self)

    def Sync(self) -> "bool":
        return _znc_core.CFile_Sync(self)

    def Open(self, *args) -> "bool":
        return _znc_core.CFile_Open(self, *args)

    def Read(self, pszBuffer: 'char *', iBytes: 'int') -> "ssize_t":
        return _znc_core.CFile_Read(self, pszBuffer, iBytes)

    def ReadLine(self, *args) -> "bool":
        return _znc_core.CFile_ReadLine(self, *args)

    def ReadFile(self, *args) -> "bool":
        return _znc_core.CFile_ReadFile(self, *args)

    def Write(self, *args) -> "ssize_t":
        return _znc_core.CFile_Write(self, *args)

    def Close(self) -> "void":
        return _znc_core.CFile_Close(self)

    def ClearBuffer(self) -> "void":
        return _znc_core.CFile_ClearBuffer(self)

    def TryExLock(self, *args) -> "bool":
        return _znc_core.CFile_TryExLock(self, *args)

    def ExLock(self) -> "bool":
        return _znc_core.CFile_ExLock(self)

    def UnLock(self) -> "bool":
        return _znc_core.CFile_UnLock(self)

    def IsOpen(self) -> "bool":
        return _znc_core.CFile_IsOpen(self)

    def GetLongName(self) -> "CString":
        return _znc_core.CFile_GetLongName(self)

    def GetShortName(self) -> "CString":
        return _znc_core.CFile_GetShortName(self)

    def GetDir(self) -> "CString":
        return _znc_core.CFile_GetDir(self)

    def HadError(self) -> "bool":
        return _znc_core.CFile_HadError(self)

    def ResetError(self) -> "void":
        return _znc_core.CFile_ResetError(self)
    __swig_getmethods__["InitHomePath"] = lambda x: _znc_core.CFile_InitHomePath
    if _newclass:
        InitHomePath = staticmethod(_znc_core.CFile_InitHomePath)
    __swig_getmethods__["GetHomePath"] = lambda x: _znc_core.CFile_GetHomePath
    if _newclass:
        GetHomePath = staticmethod(_znc_core.CFile_GetHomePath)
CFile_swigregister = _znc_core.CFile_swigregister
CFile_swigregister(CFile)

def CFile_FType(sFileName: 'CString const &', eType: 'CFile::EFileTypes', bUseLstat: 'bool'=False) -> "bool":
    return _znc_core.CFile_FType(sFileName, eType, bUseLstat)
CFile_FType = _znc_core.CFile_FType

def CFile_Exists(*args) -> "bool":
    return _znc_core.CFile_Exists(*args)
CFile_Exists = _znc_core.CFile_Exists

def CFile_GetSize(*args) -> "off_t":
    return _znc_core.CFile_GetSize(*args)
CFile_GetSize = _znc_core.CFile_GetSize

def CFile_GetATime(*args) -> "time_t":
    return _znc_core.CFile_GetATime(*args)
CFile_GetATime = _znc_core.CFile_GetATime

def CFile_GetMTime(*args) -> "time_t":
    return _znc_core.CFile_GetMTime(*args)
CFile_GetMTime = _znc_core.CFile_GetMTime

def CFile_GetCTime(*args) -> "time_t":
    return _znc_core.CFile_GetCTime(*args)
CFile_GetCTime = _znc_core.CFile_GetCTime

def CFile_GetUID(*args) -> "uid_t":
    return _znc_core.CFile_GetUID(*args)
CFile_GetUID = _znc_core.CFile_GetUID

def CFile_GetGID(*args) -> "gid_t":
    return _znc_core.CFile_GetGID(*args)
CFile_GetGID = _znc_core.CFile_GetGID

def CFile_GetInfo(sFile: 'CString const &', st: 'stat &') -> "int":
    return _znc_core.CFile_GetInfo(sFile, st)
CFile_GetInfo = _znc_core.CFile_GetInfo

def CFile_Delete(*args) -> "bool":
    return _znc_core.CFile_Delete(*args)
CFile_Delete = _znc_core.CFile_Delete

def CFile_Move(*args) -> "bool":
    return _znc_core.CFile_Move(*args)
CFile_Move = _znc_core.CFile_Move

def CFile_Copy(*args) -> "bool":
    return _znc_core.CFile_Copy(*args)
CFile_Copy = _znc_core.CFile_Copy

def CFile_Chmod(*args) -> "bool":
    return _znc_core.CFile_Chmod(*args)
CFile_Chmod = _znc_core.CFile_Chmod

def CFile_InitHomePath(sFallback: 'CString const &') -> "void":
    return _znc_core.CFile_InitHomePath(sFallback)
CFile_InitHomePath = _znc_core.CFile_InitHomePath

def CFile_GetHomePath() -> "CString const &":
    return _znc_core.CFile_GetHomePath()
CFile_GetHomePath = _znc_core.CFile_GetHomePath

class CDir(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CDir, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CDir, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CDir(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CDir
    __del__ = lambda self: None

    def CleanUp(self) -> "void":
        return _znc_core.CDir_CleanUp(self)

    def Fill(self, sDir: 'CString const &') -> "size_t":
        return _znc_core.CDir_Fill(self, sDir)

    def FillByWildcard(self, sDir: 'CString const &', sWildcard: 'CString const &') -> "size_t":
        return _znc_core.CDir_FillByWildcard(self, sDir, sWildcard)

    def Chmod(self, *args) -> "unsigned int":
        return _znc_core.CDir_Chmod(self, *args)

    def Delete(self, *args) -> "unsigned int":
        return _znc_core.CDir_Delete(self, *args)

    def GetSortAttr(self) -> "CFile::EFileAttr":
        return _znc_core.CDir_GetSortAttr(self)

    def IsDescending(self) -> "bool":
        return _znc_core.CDir_IsDescending(self)
    __swig_getmethods__["CheckPathPrefix"] = lambda x: _znc_core.CDir_CheckPathPrefix
    if _newclass:
        CheckPathPrefix = staticmethod(_znc_core.CDir_CheckPathPrefix)
    __swig_getmethods__["ChangeDir"] = lambda x: _znc_core.CDir_ChangeDir
    if _newclass:
        ChangeDir = staticmethod(_znc_core.CDir_ChangeDir)
    __swig_getmethods__["MakeDir"] = lambda x: _znc_core.CDir_MakeDir
    if _newclass:
        MakeDir = staticmethod(_znc_core.CDir_MakeDir)
    __swig_getmethods__["GetCWD"] = lambda x: _znc_core.CDir_GetCWD
    if _newclass:
        GetCWD = staticmethod(_znc_core.CDir_GetCWD)
CDir_swigregister = _znc_core.CDir_swigregister
CDir_swigregister(CDir)

def CDir_CheckPathPrefix(*args) -> "CString":
    return _znc_core.CDir_CheckPathPrefix(*args)
CDir_CheckPathPrefix = _znc_core.CDir_CheckPathPrefix

def CDir_ChangeDir(*args) -> "CString":
    return _znc_core.CDir_ChangeDir(*args)
CDir_ChangeDir = _znc_core.CDir_ChangeDir

def CDir_MakeDir(sPath: 'CString const &', iMode: 'mode_t'=0o700) -> "bool":
    return _znc_core.CDir_MakeDir(sPath, iMode)
CDir_MakeDir = _znc_core.CDir_MakeDir

def CDir_GetCWD() -> "CString":
    return _znc_core.CDir_GetCWD()
CDir_GetCWD = _znc_core.CDir_GetCWD

class CTimer(CCron):
    __swig_setmethods__ = {}
    for _s in [CCron]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CTimer, name, value)
    __swig_getmethods__ = {}
    for _s in [CCron]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CTimer, name)
    __repr__ = _swig_repr

    def __init__(self, pModule: 'CModule', uInterval: 'unsigned int', uCycles: 'unsigned int', sLabel: 'CString const &', sDescription: 'CString const &'):
        this = _znc_core.new_CTimer(pModule, uInterval, uCycles, sLabel, sDescription)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CTimer
    __del__ = lambda self: None

    def SetModule(self, p: 'CModule') -> "void":
        return _znc_core.CTimer_SetModule(self, p)

    def SetDescription(self, s: 'CString const &') -> "void":
        return _znc_core.CTimer_SetDescription(self, s)

    def GetModule(self) -> "CModule *":
        return _znc_core.CTimer_GetModule(self)

    def GetDescription(self) -> "CString const &":
        return _znc_core.CTimer_GetDescription(self)
CTimer_swigregister = _znc_core.CTimer_swigregister
CTimer_swigregister(CTimer)

class CFPTimer(CTimer):
    __swig_setmethods__ = {}
    for _s in [CTimer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CFPTimer, name, value)
    __swig_getmethods__ = {}
    for _s in [CTimer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CFPTimer, name)
    __repr__ = _swig_repr

    def __init__(self, pModule: 'CModule', uInterval: 'unsigned int', uCycles: 'unsigned int', sLabel: 'CString const &', sDescription: 'CString const &'):
        this = _znc_core.new_CFPTimer(pModule, uInterval, uCycles, sLabel, sDescription)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CFPTimer
    __del__ = lambda self: None

    def SetFPCallback(self, p: 'FPTimer_t') -> "void":
        return _znc_core.CFPTimer_SetFPCallback(self, p)
CFPTimer_swigregister = _znc_core.CFPTimer_swigregister
CFPTimer_swigregister(CFPTimer)

class CModInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CModInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CModInfo, name)
    __repr__ = _swig_repr
    GlobalModule = _znc_core.CModInfo_GlobalModule
    UserModule = _znc_core.CModInfo_UserModule
    NetworkModule = _znc_core.CModInfo_NetworkModule

    def __init__(self, *args):
        this = _znc_core.new_CModInfo(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CModInfo
    __del__ = lambda self: None

    def __lt__(self, Info: 'CModInfo') -> "bool":
        return _znc_core.CModInfo___lt__(self, Info)

    def SupportsType(self, eType: 'CModInfo::EModuleType') -> "bool":
        return _znc_core.CModInfo_SupportsType(self, eType)

    def AddType(self, eType: 'CModInfo::EModuleType') -> "void":
        return _znc_core.CModInfo_AddType(self, eType)
    __swig_getmethods__["ModuleTypeToString"] = lambda x: _znc_core.CModInfo_ModuleTypeToString
    if _newclass:
        ModuleTypeToString = staticmethod(_znc_core.CModInfo_ModuleTypeToString)

    def GetName(self) -> "CString const &":
        return _znc_core.CModInfo_GetName(self)

    def GetPath(self) -> "CString const &":
        return _znc_core.CModInfo_GetPath(self)

    def GetDescription(self) -> "CString const &":
        return _znc_core.CModInfo_GetDescription(self)

    def GetWikiPage(self) -> "CString const &":
        return _znc_core.CModInfo_GetWikiPage(self)

    def GetArgsHelpText(self) -> "CString const &":
        return _znc_core.CModInfo_GetArgsHelpText(self)

    def GetHasArgs(self) -> "bool":
        return _znc_core.CModInfo_GetHasArgs(self)

    def GetLoader(self) -> "CModInfo::ModLoader":
        return _znc_core.CModInfo_GetLoader(self)

    def GetDefaultType(self) -> "CModInfo::EModuleType":
        return _znc_core.CModInfo_GetDefaultType(self)

    def SetName(self, s: 'CString const &') -> "void":
        return _znc_core.CModInfo_SetName(self, s)

    def SetPath(self, s: 'CString const &') -> "void":
        return _znc_core.CModInfo_SetPath(self, s)

    def SetDescription(self, s: 'CString const &') -> "void":
        return _znc_core.CModInfo_SetDescription(self, s)

    def SetWikiPage(self, s: 'CString const &') -> "void":
        return _znc_core.CModInfo_SetWikiPage(self, s)

    def SetArgsHelpText(self, s: 'CString const &') -> "void":
        return _znc_core.CModInfo_SetArgsHelpText(self, s)

    def SetHasArgs(self, b: 'bool'=False) -> "void":
        return _znc_core.CModInfo_SetHasArgs(self, b)

    def SetLoader(self, fLoader: 'CModInfo::ModLoader') -> "void":
        return _znc_core.CModInfo_SetLoader(self, fLoader)

    def SetDefaultType(self, eType: 'CModInfo::EModuleType') -> "void":
        return _znc_core.CModInfo_SetDefaultType(self, eType)
CModInfo_swigregister = _znc_core.CModInfo_swigregister
CModInfo_swigregister(CModInfo)

def CModInfo_ModuleTypeToString(eType: 'CModInfo::EModuleType') -> "CString":
    return _znc_core.CModInfo_ModuleTypeToString(eType)
CModInfo_ModuleTypeToString = _znc_core.CModInfo_ModuleTypeToString

class CModCommand(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CModCommand, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CModCommand, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CModCommand(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_getmethods__["InitHelp"] = lambda x: _znc_core.CModCommand_InitHelp
    if _newclass:
        InitHelp = staticmethod(_znc_core.CModCommand_InitHelp)

    def AddHelp(self, Table: 'CTable') -> "void":
        return _znc_core.CModCommand_AddHelp(self, Table)

    def GetCommand(self) -> "CString const &":
        return _znc_core.CModCommand_GetCommand(self)

    def GetFunction(self) -> "CModCommand::CmdFunc":
        return _znc_core.CModCommand_GetFunction(self)

    def GetArgs(self) -> "CString const &":
        return _znc_core.CModCommand_GetArgs(self)

    def GetDescription(self) -> "CString const &":
        return _znc_core.CModCommand_GetDescription(self)

    def Call(self, sLine: 'CString const &') -> "void":
        return _znc_core.CModCommand_Call(self, sLine)
    __swig_destroy__ = _znc_core.delete_CModCommand
    __del__ = lambda self: None
CModCommand_swigregister = _znc_core.CModCommand_swigregister
CModCommand_swigregister(CModCommand)

def CModCommand_InitHelp(Table: 'CTable') -> "void":
    return _znc_core.CModCommand_InitHelp(Table)
CModCommand_InitHelp = _znc_core.CModCommand_InitHelp

class CModule(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CModule, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CModule, name)
    __repr__ = _swig_repr

    def __init__(self, pDLL: 'ModHandle', pUser: 'CUser', pNetwork: 'CIRCNetwork', sModName: 'CString const &', sDataDir: 'CString const &'):
        this = _znc_core.new_CModule(pDLL, pUser, pNetwork, sModName, sDataDir)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CModule
    __del__ = lambda self: None
    CONTINUE = _znc_core.CModule_CONTINUE
    HALT = _znc_core.CModule_HALT
    HALTMODS = _znc_core.CModule_HALTMODS
    HALTCORE = _znc_core.CModule_HALTCORE
    UNLOAD = _znc_core.CModule_UNLOAD

    def SetUser(self, pUser: 'CUser') -> "void":
        return _znc_core.CModule_SetUser(self, pUser)

    def SetNetwork(self, pNetwork: 'CIRCNetwork') -> "void":
        return _znc_core.CModule_SetNetwork(self, pNetwork)

    def SetClient(self, pClient: 'CClient') -> "void":
        return _znc_core.CModule_SetClient(self, pClient)

    def Unload(self) -> "void":
        return _znc_core.CModule_Unload(self)

    def OnLoad(self, sArgsi: 'CString const &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModule_OnLoad(self, sArgsi, sMessage)

    def OnBoot(self) -> "bool":
        return _znc_core.CModule_OnBoot(self)

    def WebRequiresLogin(self) -> "bool":
        return _znc_core.CModule_WebRequiresLogin(self)

    def WebRequiresAdmin(self) -> "bool":
        return _znc_core.CModule_WebRequiresAdmin(self)

    def GetWebMenuTitle(self) -> "CString":
        return _znc_core.CModule_GetWebMenuTitle(self)

    def GetWebPath(self) -> "CString":
        return _znc_core.CModule_GetWebPath(self)

    def GetWebFilesPath(self) -> "CString":
        return _znc_core.CModule_GetWebFilesPath(self)

    def OnWebPreRequest(self, WebSock: 'CWebSock', sPageName: 'CString const &') -> "bool":
        return _znc_core.CModule_OnWebPreRequest(self, WebSock, sPageName)

    def OnWebRequest(self, WebSock: 'CWebSock', sPageName: 'CString const &', Tmpl: 'CTemplate') -> "bool":
        return _znc_core.CModule_OnWebRequest(self, WebSock, sPageName, Tmpl)

    def AddSubPage(self, spSubPage: 'TWebSubPage') -> "void":
        return _znc_core.CModule_AddSubPage(self, spSubPage)

    def ClearSubPages(self) -> "void":
        return _znc_core.CModule_ClearSubPages(self)

    def GetSubPages(self) -> "VWebSubPages &":
        return _znc_core.CModule_GetSubPages(self)

    def OnEmbeddedWebRequest(self, WebSock: 'CWebSock', sPageName: 'CString const &', Tmpl: 'CTemplate') -> "bool":
        return _znc_core.CModule_OnEmbeddedWebRequest(self, WebSock, sPageName, Tmpl)

    def OnPreRehash(self) -> "void":
        return _znc_core.CModule_OnPreRehash(self)

    def OnPostRehash(self) -> "void":
        return _znc_core.CModule_OnPostRehash(self)

    def OnIRCDisconnected(self) -> "void":
        return _znc_core.CModule_OnIRCDisconnected(self)

    def OnIRCConnected(self) -> "void":
        return _znc_core.CModule_OnIRCConnected(self)

    def OnIRCConnecting(self, pIRCSock: 'CIRCSock') -> "CModule::EModRet":
        return _znc_core.CModule_OnIRCConnecting(self, pIRCSock)

    def OnIRCConnectionError(self, pIRCSock: 'CIRCSock') -> "void":
        return _znc_core.CModule_OnIRCConnectionError(self, pIRCSock)

    def OnIRCRegistration(self, sPass: 'CString &', sNick: 'CString &', sIdent: 'CString &', sRealName: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnIRCRegistration(self, sPass, sNick, sIdent, sRealName)

    def OnBroadcast(self, sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnBroadcast(self, sMessage)

    def OnChanPermission2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', uMode: 'unsigned char', bAdded: 'bool', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnChanPermission(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', uMode: 'unsigned char', bAdded: 'bool', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnChanPermission(self, OpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnOp2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnOp2(self, pOpNick, Nick, Channel, bNoChange)

    def OnOp(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnOp(self, OpNick, Nick, Channel, bNoChange)

    def OnDeop2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnDeop2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDeop(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnDeop(self, OpNick, Nick, Channel, bNoChange)

    def OnVoice2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnVoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnVoice(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnVoice(self, OpNick, Nick, Channel, bNoChange)

    def OnDevoice2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnDevoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDevoice(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnDevoice(self, OpNick, Nick, Channel, bNoChange)

    def OnMode2(self, pOpNick: 'CNick', Channel: 'CChan', uMode: 'char', sArg: 'CString const &', bAdded: 'bool', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnMode(self, OpNick: 'CNick', Channel: 'CChan', uMode: 'char', sArg: 'CString const &', bAdded: 'bool', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnMode(self, OpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnRawMode2(self, pOpNick: 'CNick', Channel: 'CChan', sModes: 'CString const &', sArgs: 'CString const &') -> "void":
        return _znc_core.CModule_OnRawMode2(self, pOpNick, Channel, sModes, sArgs)

    def OnRawMode(self, OpNick: 'CNick', Channel: 'CChan', sModes: 'CString const &', sArgs: 'CString const &') -> "void":
        return _znc_core.CModule_OnRawMode(self, OpNick, Channel, sModes, sArgs)

    def OnRaw(self, sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnRaw(self, sLine)

    def OnStatusCommand(self, sCommand: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnStatusCommand(self, sCommand)

    def OnModCommand(self, sCommand: 'CString const &') -> "void":
        return _znc_core.CModule_OnModCommand(self, sCommand)

    def OnUnknownModCommand(self, sCommand: 'CString const &') -> "void":
        return _znc_core.CModule_OnUnknownModCommand(self, sCommand)

    def OnModNotice(self, sMessage: 'CString const &') -> "void":
        return _znc_core.CModule_OnModNotice(self, sMessage)

    def OnModCTCP(self, sMessage: 'CString const &') -> "void":
        return _znc_core.CModule_OnModCTCP(self, sMessage)

    def OnQuit(self, Nick: 'CNick', sMessage: 'CString const &', vChans: 'VChannels') -> "void":
        return _znc_core.CModule_OnQuit(self, Nick, sMessage, vChans)

    def OnNick(self, Nick: 'CNick', sNewNick: 'CString const &', vChans: 'VChannels') -> "void":
        return _znc_core.CModule_OnNick(self, Nick, sNewNick, vChans)

    def OnKick(self, OpNick: 'CNick', sKickedNick: 'CString const &', Channel: 'CChan', sMessage: 'CString const &') -> "void":
        return _znc_core.CModule_OnKick(self, OpNick, sKickedNick, Channel, sMessage)

    def OnJoining(self, Channel: 'CChan') -> "CModule::EModRet":
        return _znc_core.CModule_OnJoining(self, Channel)

    def OnJoin(self, Nick: 'CNick', Channel: 'CChan') -> "void":
        return _znc_core.CModule_OnJoin(self, Nick, Channel)

    def OnPart(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString const &') -> "void":
        return _znc_core.CModule_OnPart(self, Nick, Channel, sMessage)

    def OnInvite(self, Nick: 'CNick', sChan: 'CString const &') -> "CModule::EModRet":
        return _znc_core.CModule_OnInvite(self, Nick, sChan)

    def OnChanBufferStarting(self, Chan: 'CChan', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanBufferStarting(self, Chan, Client)

    def OnChanBufferEnding(self, Chan: 'CChan', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanBufferEnding(self, Chan, Client)

    def OnChanBufferPlayLine2(self, Chan: 'CChan', Client: 'CClient', sLine: 'CString &', tv: 'timeval const &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanBufferPlayLine2(self, Chan, Client, sLine, tv)

    def OnChanBufferPlayLine(self, Chan: 'CChan', Client: 'CClient', sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanBufferPlayLine(self, Chan, Client, sLine)

    def OnPrivBufferPlayLine2(self, Client: 'CClient', sLine: 'CString &', tv: 'timeval const &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivBufferPlayLine2(self, Client, sLine, tv)

    def OnPrivBufferPlayLine(self, Client: 'CClient', sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivBufferPlayLine(self, Client, sLine)

    def OnClientLogin(self) -> "void":
        return _znc_core.CModule_OnClientLogin(self)

    def OnClientDisconnect(self) -> "void":
        return _znc_core.CModule_OnClientDisconnect(self)

    def OnUserRaw(self, sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserRaw(self, sLine)

    def OnUserCTCPReply(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserCTCPReply(self, sTarget, sMessage)

    def OnUserCTCP(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserCTCP(self, sTarget, sMessage)

    def OnUserAction(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserAction(self, sTarget, sMessage)

    def OnUserMsg(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserMsg(self, sTarget, sMessage)

    def OnUserNotice(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserNotice(self, sTarget, sMessage)

    def OnUserJoin(self, sChannel: 'CString &', sKey: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserJoin(self, sChannel, sKey)

    def OnUserPart(self, sChannel: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserPart(self, sChannel, sMessage)

    def OnUserTopic(self, sChannel: 'CString &', sTopic: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserTopic(self, sChannel, sTopic)

    def OnUserTopicRequest(self, sChannel: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserTopicRequest(self, sChannel)

    def OnCTCPReply(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnCTCPReply(self, Nick, sMessage)

    def OnPrivCTCP(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivCTCP(self, Nick, sMessage)

    def OnChanCTCP(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanCTCP(self, Nick, Channel, sMessage)

    def OnPrivAction(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivAction(self, Nick, sMessage)

    def OnChanAction(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanAction(self, Nick, Channel, sMessage)

    def OnPrivMsg(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivMsg(self, Nick, sMessage)

    def OnChanMsg(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanMsg(self, Nick, Channel, sMessage)

    def OnPrivNotice(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivNotice(self, Nick, sMessage)

    def OnChanNotice(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanNotice(self, Nick, Channel, sMessage)

    def OnTopic(self, Nick: 'CNick', Channel: 'CChan', sTopic: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnTopic(self, Nick, Channel, sTopic)

    def OnServerCapAvailable(self, sCap: 'CString const &') -> "bool":
        return _znc_core.CModule_OnServerCapAvailable(self, sCap)

    def OnServerCapResult(self, sCap: 'CString const &', bSuccess: 'bool') -> "void":
        return _znc_core.CModule_OnServerCapResult(self, sCap, bSuccess)

    def OnTimerAutoJoin(self, Channel: 'CChan') -> "CModule::EModRet":
        return _znc_core.CModule_OnTimerAutoJoin(self, Channel)

    def OnAddNetwork(self, Network: 'CIRCNetwork', sErrorRet: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnAddNetwork(self, Network, sErrorRet)

    def OnDeleteNetwork(self, Network: 'CIRCNetwork') -> "CModule::EModRet":
        return _znc_core.CModule_OnDeleteNetwork(self, Network)

    def OnSendToClient(self, sLine: 'CString &', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CModule_OnSendToClient(self, sLine, Client)

    def OnSendToIRC(self, sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnSendToIRC(self, sLine)

    def GetDLL(self) -> "ModHandle":
        return _znc_core.CModule_GetDLL(self)
    __swig_getmethods__["GetCoreVersion"] = lambda x: _znc_core.CModule_GetCoreVersion
    if _newclass:
        GetCoreVersion = staticmethod(_znc_core.CModule_GetCoreVersion)

    def PutIRC(self, sLine: 'CString const &') -> "bool":
        return _znc_core.CModule_PutIRC(self, sLine)

    def PutUser(self, sLine: 'CString const &') -> "bool":
        return _znc_core.CModule_PutUser(self, sLine)

    def PutStatus(self, sLine: 'CString const &') -> "bool":
        return _znc_core.CModule_PutStatus(self, sLine)

    def PutModule(self, *args) -> "unsigned int":
        return _znc_core.CModule_PutModule(self, *args)

    def PutModNotice(self, sLine: 'CString const &') -> "bool":
        return _znc_core.CModule_PutModNotice(self, sLine)

    def GetModName(self) -> "CString const &":
        return _znc_core.CModule_GetModName(self)

    def GetModNick(self) -> "CString":
        return _znc_core.CModule_GetModNick(self)

    def GetModDataDir(self) -> "CString const &":
        return _znc_core.CModule_GetModDataDir(self)

    def AddTimer(self, *args) -> "bool":
        return _znc_core.CModule_AddTimer(self, *args)

    def RemTimer(self, *args) -> "bool":
        return _znc_core.CModule_RemTimer(self, *args)

    def UnlinkTimer(self, pTimer: 'CTimer') -> "bool":
        return _znc_core.CModule_UnlinkTimer(self, pTimer)

    def FindTimer(self, sLabel: 'CString const &') -> "CTimer *":
        return _znc_core.CModule_FindTimer(self, sLabel)

    def BeginTimers(self) -> "std::set< CTimer *,std::less< CTimer * >,std::allocator< CTimer * > >::const_iterator":
        return _znc_core.CModule_BeginTimers(self)

    def EndTimers(self) -> "std::set< CTimer *,std::less< CTimer * >,std::allocator< CTimer * > >::const_iterator":
        return _znc_core.CModule_EndTimers(self)

    def ListTimers(self) -> "void":
        return _znc_core.CModule_ListTimers(self)

    def AddSocket(self, pSocket: 'CSocket') -> "bool":
        return _znc_core.CModule_AddSocket(self, pSocket)

    def RemSocket(self, *args) -> "bool":
        return _znc_core.CModule_RemSocket(self, *args)

    def UnlinkSocket(self, pSocket: 'CSocket') -> "bool":
        return _znc_core.CModule_UnlinkSocket(self, pSocket)

    def FindSocket(self, sSockName: 'CString const &') -> "CSocket *":
        return _znc_core.CModule_FindSocket(self, sSockName)

    def BeginSockets(self) -> "std::set< CSocket *,std::less< CSocket * >,std::allocator< CSocket * > >::const_iterator":
        return _znc_core.CModule_BeginSockets(self)

    def EndSockets(self) -> "std::set< CSocket *,std::less< CSocket * >,std::allocator< CSocket * > >::const_iterator":
        return _znc_core.CModule_EndSockets(self)

    def ListSockets(self) -> "void":
        return _znc_core.CModule_ListSockets(self)

    def AddHelpCommand(self) -> "void":
        return _znc_core.CModule_AddHelpCommand(self)

    def AddCommand(self, *args) -> "bool":
        return _znc_core.CModule_AddCommand(self, *args)

    def RemCommand(self, sCmd: 'CString const &') -> "bool":
        return _znc_core.CModule_RemCommand(self, sCmd)

    def FindCommand(self, sCmd: 'CString const &') -> "CModCommand const *":
        return _znc_core.CModule_FindCommand(self, sCmd)

    def HandleCommand(self, sLine: 'CString const &') -> "bool":
        return _znc_core.CModule_HandleCommand(self, sLine)

    def HandleHelpCommand(self, *args) -> "void":
        return _znc_core.CModule_HandleHelpCommand(self, *args)

    def LoadRegistry(self) -> "bool":
        return _znc_core.CModule_LoadRegistry(self)

    def SaveRegistry(self) -> "bool":
        return _znc_core.CModule_SaveRegistry(self)

    def MoveRegistry(self, sPath: 'CString const &') -> "bool":
        return _znc_core.CModule_MoveRegistry(self, sPath)

    def SetNV(self, sName: 'CString const &', sValue: 'CString const &', bWriteToDisk: 'bool'=True) -> "bool":
        return _znc_core.CModule_SetNV(self, sName, sValue, bWriteToDisk)

    def GetNV(self, sName: 'CString const &') -> "CString":
        return _znc_core.CModule_GetNV(self, sName)

    def FindNV(self, sName: 'CString const &') -> "MCString::iterator":
        return _znc_core.CModule_FindNV(self, sName)

    def EndNV(self) -> "MCString::iterator":
        return _znc_core.CModule_EndNV(self)

    def BeginNV(self) -> "MCString::iterator":
        return _znc_core.CModule_BeginNV(self)

    def DelNV(self, *args) -> "void":
        return _znc_core.CModule_DelNV(self, *args)

    def ClearNV(self, bWriteToDisk: 'bool'=True) -> "bool":
        return _znc_core.CModule_ClearNV(self, bWriteToDisk)

    def GetSavePath(self) -> "CString const &":
        return _znc_core.CModule_GetSavePath(self)

    def ExpandString(self, *args) -> "CString &":
        return _znc_core.CModule_ExpandString(self, *args)

    def SetType(self, eType: 'CModInfo::EModuleType') -> "void":
        return _znc_core.CModule_SetType(self, eType)

    def SetDescription(self, s: 'CString const &') -> "void":
        return _znc_core.CModule_SetDescription(self, s)

    def SetModPath(self, s: 'CString const &') -> "void":
        return _znc_core.CModule_SetModPath(self, s)

    def SetArgs(self, s: 'CString const &') -> "void":
        return _znc_core.CModule_SetArgs(self, s)

    def GetType(self) -> "CModInfo::EModuleType":
        return _znc_core.CModule_GetType(self)

    def GetDescription(self) -> "CString const &":
        return _znc_core.CModule_GetDescription(self)

    def GetArgs(self) -> "CString const &":
        return _znc_core.CModule_GetArgs(self)

    def GetModPath(self) -> "CString const &":
        return _znc_core.CModule_GetModPath(self)

    def GetUser(self) -> "CUser *":
        return _znc_core.CModule_GetUser(self)

    def GetNetwork(self) -> "CIRCNetwork *":
        return _znc_core.CModule_GetNetwork(self)

    def GetClient(self) -> "CClient *":
        return _znc_core.CModule_GetClient(self)

    def GetManager(self) -> "CSockManager *":
        return _znc_core.CModule_GetManager(self)

    def OnAddUser(self, User: 'CUser', sErrorRet: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnAddUser(self, User, sErrorRet)

    def OnDeleteUser(self, User: 'CUser') -> "CModule::EModRet":
        return _znc_core.CModule_OnDeleteUser(self, User)

    def OnClientConnect(self, pSock: 'CZNCSock', sHost: 'CString const &', uPort: 'unsigned short') -> "void":
        return _znc_core.CModule_OnClientConnect(self, pSock, sHost, uPort)

    def OnLoginAttempt(self, Auth: 'std::shared_ptr< CAuthBase >') -> "CModule::EModRet":
        return _znc_core.CModule_OnLoginAttempt(self, Auth)

    def OnFailedLogin(self, sUsername: 'CString const &', sRemoteIP: 'CString const &') -> "void":
        return _znc_core.CModule_OnFailedLogin(self, sUsername, sRemoteIP)

    def OnUnknownUserRaw(self, pClient: 'CClient', sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUnknownUserRaw(self, pClient, sLine)

    def OnClientCapLs(self, pClient: 'CClient', ssCaps: 'SCString') -> "void":
        return _znc_core.CModule_OnClientCapLs(self, pClient, ssCaps)

    def IsClientCapSupported(self, pClient: 'CClient', sCap: 'CString const &', bState: 'bool') -> "bool":
        return _znc_core.CModule_IsClientCapSupported(self, pClient, sCap, bState)

    def OnClientCapRequest(self, pClient: 'CClient', sCap: 'CString const &', bState: 'bool') -> "void":
        return _znc_core.CModule_OnClientCapRequest(self, pClient, sCap, bState)

    def OnModuleLoading(self, sModName: 'CString const &', sArgs: 'CString const &', eType: 'CModInfo::EModuleType', bSuccess: 'bool &', sRetMsg: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg)

    def OnModuleUnloading(self, pModule: 'CModule', bSuccess: 'bool &', sRetMsg: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnModuleUnloading(self, pModule, bSuccess, sRetMsg)

    def OnGetModInfo(self, ModInfo: 'CModInfo', sModule: 'CString const &', bSuccess: 'bool &', sRetMsg: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg)

    def OnGetAvailableMods(self, ssMods: 'SModInfo', eType: 'CModInfo::EModuleType') -> "void":
        return _znc_core.CModule_OnGetAvailableMods(self, ssMods, eType)

    def __str__(self) -> "CString":
        return _znc_core.CModule___str__(self)

    def BeginNV_(self) -> "MCString_iter":
        return _znc_core.CModule_BeginNV_(self)

    def ExistsNV(self, sName: 'CString const &') -> "bool":
        return _znc_core.CModule_ExistsNV(self, sName)
CModule_swigregister = _znc_core.CModule_swigregister
CModule_swigregister(CModule)

def CModule_GetCoreVersion() -> "double":
    return _znc_core.CModule_GetCoreVersion()
CModule_GetCoreVersion = _znc_core.CModule_GetCoreVersion

class CModules(PyModulesVector):
    __swig_setmethods__ = {}
    for _s in [PyModulesVector]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CModules, name, value)
    __swig_getmethods__ = {}
    for _s in [PyModulesVector]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CModules, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CModules()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CModules
    __del__ = lambda self: None

    def SetUser(self, pUser: 'CUser') -> "void":
        return _znc_core.CModules_SetUser(self, pUser)

    def SetNetwork(self, pNetwork: 'CIRCNetwork') -> "void":
        return _znc_core.CModules_SetNetwork(self, pNetwork)

    def SetClient(self, pClient: 'CClient') -> "void":
        return _znc_core.CModules_SetClient(self, pClient)

    def GetUser(self) -> "CUser *":
        return _znc_core.CModules_GetUser(self)

    def GetNetwork(self) -> "CIRCNetwork *":
        return _znc_core.CModules_GetNetwork(self)

    def GetClient(self) -> "CClient *":
        return _znc_core.CModules_GetClient(self)

    def UnloadAll(self) -> "void":
        return _znc_core.CModules_UnloadAll(self)

    def OnBoot(self) -> "bool":
        return _znc_core.CModules_OnBoot(self)

    def OnPreRehash(self) -> "bool":
        return _znc_core.CModules_OnPreRehash(self)

    def OnPostRehash(self) -> "bool":
        return _znc_core.CModules_OnPostRehash(self)

    def OnIRCDisconnected(self) -> "bool":
        return _znc_core.CModules_OnIRCDisconnected(self)

    def OnIRCConnected(self) -> "bool":
        return _znc_core.CModules_OnIRCConnected(self)

    def OnIRCConnecting(self, pIRCSock: 'CIRCSock') -> "bool":
        return _znc_core.CModules_OnIRCConnecting(self, pIRCSock)

    def OnIRCConnectionError(self, pIRCSock: 'CIRCSock') -> "bool":
        return _znc_core.CModules_OnIRCConnectionError(self, pIRCSock)

    def OnIRCRegistration(self, sPass: 'CString &', sNick: 'CString &', sIdent: 'CString &', sRealName: 'CString &') -> "bool":
        return _znc_core.CModules_OnIRCRegistration(self, sPass, sNick, sIdent, sRealName)

    def OnBroadcast(self, sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnBroadcast(self, sMessage)

    def OnChanPermission2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', uMode: 'unsigned char', bAdded: 'bool', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnChanPermission(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', uMode: 'unsigned char', bAdded: 'bool', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnChanPermission(self, OpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnOp2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnOp2(self, pOpNick, Nick, Channel, bNoChange)

    def OnOp(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnOp(self, OpNick, Nick, Channel, bNoChange)

    def OnDeop2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnDeop2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDeop(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnDeop(self, OpNick, Nick, Channel, bNoChange)

    def OnVoice2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnVoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnVoice(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnVoice(self, OpNick, Nick, Channel, bNoChange)

    def OnDevoice2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnDevoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDevoice(self, OpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnDevoice(self, OpNick, Nick, Channel, bNoChange)

    def OnRawMode2(self, pOpNick: 'CNick', Channel: 'CChan', sModes: 'CString const &', sArgs: 'CString const &') -> "bool":
        return _znc_core.CModules_OnRawMode2(self, pOpNick, Channel, sModes, sArgs)

    def OnRawMode(self, OpNick: 'CNick', Channel: 'CChan', sModes: 'CString const &', sArgs: 'CString const &') -> "bool":
        return _znc_core.CModules_OnRawMode(self, OpNick, Channel, sModes, sArgs)

    def OnMode2(self, pOpNick: 'CNick', Channel: 'CChan', uMode: 'char', sArg: 'CString const &', bAdded: 'bool', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnMode(self, OpNick: 'CNick', Channel: 'CChan', uMode: 'char', sArg: 'CString const &', bAdded: 'bool', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnMode(self, OpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnRaw(self, sLine: 'CString &') -> "bool":
        return _znc_core.CModules_OnRaw(self, sLine)

    def OnStatusCommand(self, sCommand: 'CString &') -> "bool":
        return _znc_core.CModules_OnStatusCommand(self, sCommand)

    def OnModCommand(self, sCommand: 'CString const &') -> "bool":
        return _znc_core.CModules_OnModCommand(self, sCommand)

    def OnModNotice(self, sMessage: 'CString const &') -> "bool":
        return _znc_core.CModules_OnModNotice(self, sMessage)

    def OnModCTCP(self, sMessage: 'CString const &') -> "bool":
        return _znc_core.CModules_OnModCTCP(self, sMessage)

    def OnQuit(self, Nick: 'CNick', sMessage: 'CString const &', vChans: 'VChannels') -> "bool":
        return _znc_core.CModules_OnQuit(self, Nick, sMessage, vChans)

    def OnNick(self, Nick: 'CNick', sNewNick: 'CString const &', vChans: 'VChannels') -> "bool":
        return _znc_core.CModules_OnNick(self, Nick, sNewNick, vChans)

    def OnKick(self, Nick: 'CNick', sOpNick: 'CString const &', Channel: 'CChan', sMessage: 'CString const &') -> "bool":
        return _znc_core.CModules_OnKick(self, Nick, sOpNick, Channel, sMessage)

    def OnJoining(self, Channel: 'CChan') -> "bool":
        return _znc_core.CModules_OnJoining(self, Channel)

    def OnJoin(self, Nick: 'CNick', Channel: 'CChan') -> "bool":
        return _znc_core.CModules_OnJoin(self, Nick, Channel)

    def OnPart(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString const &') -> "bool":
        return _znc_core.CModules_OnPart(self, Nick, Channel, sMessage)

    def OnInvite(self, Nick: 'CNick', sChan: 'CString const &') -> "bool":
        return _znc_core.CModules_OnInvite(self, Nick, sChan)

    def OnChanBufferStarting(self, Chan: 'CChan', Client: 'CClient') -> "bool":
        return _znc_core.CModules_OnChanBufferStarting(self, Chan, Client)

    def OnChanBufferEnding(self, Chan: 'CChan', Client: 'CClient') -> "bool":
        return _znc_core.CModules_OnChanBufferEnding(self, Chan, Client)

    def OnChanBufferPlayLine2(self, Chan: 'CChan', Client: 'CClient', sLine: 'CString &', tv: 'timeval const &') -> "bool":
        return _znc_core.CModules_OnChanBufferPlayLine2(self, Chan, Client, sLine, tv)

    def OnChanBufferPlayLine(self, Chan: 'CChan', Client: 'CClient', sLine: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanBufferPlayLine(self, Chan, Client, sLine)

    def OnPrivBufferPlayLine2(self, Client: 'CClient', sLine: 'CString &', tv: 'timeval const &') -> "bool":
        return _znc_core.CModules_OnPrivBufferPlayLine2(self, Client, sLine, tv)

    def OnPrivBufferPlayLine(self, Client: 'CClient', sLine: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivBufferPlayLine(self, Client, sLine)

    def OnClientLogin(self) -> "bool":
        return _znc_core.CModules_OnClientLogin(self)

    def OnClientDisconnect(self) -> "bool":
        return _znc_core.CModules_OnClientDisconnect(self)

    def OnUserRaw(self, sLine: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserRaw(self, sLine)

    def OnUserCTCPReply(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserCTCPReply(self, sTarget, sMessage)

    def OnUserCTCP(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserCTCP(self, sTarget, sMessage)

    def OnUserAction(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserAction(self, sTarget, sMessage)

    def OnUserMsg(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserMsg(self, sTarget, sMessage)

    def OnUserNotice(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserNotice(self, sTarget, sMessage)

    def OnUserJoin(self, sChannel: 'CString &', sKey: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserJoin(self, sChannel, sKey)

    def OnUserPart(self, sChannel: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserPart(self, sChannel, sMessage)

    def OnUserTopic(self, sChannel: 'CString &', sTopic: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserTopic(self, sChannel, sTopic)

    def OnUserTopicRequest(self, sChannel: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserTopicRequest(self, sChannel)

    def OnCTCPReply(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnCTCPReply(self, Nick, sMessage)

    def OnPrivCTCP(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivCTCP(self, Nick, sMessage)

    def OnChanCTCP(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanCTCP(self, Nick, Channel, sMessage)

    def OnPrivAction(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivAction(self, Nick, sMessage)

    def OnChanAction(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanAction(self, Nick, Channel, sMessage)

    def OnPrivMsg(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivMsg(self, Nick, sMessage)

    def OnChanMsg(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanMsg(self, Nick, Channel, sMessage)

    def OnPrivNotice(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivNotice(self, Nick, sMessage)

    def OnChanNotice(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanNotice(self, Nick, Channel, sMessage)

    def OnTopic(self, Nick: 'CNick', Channel: 'CChan', sTopic: 'CString &') -> "bool":
        return _znc_core.CModules_OnTopic(self, Nick, Channel, sTopic)

    def OnTimerAutoJoin(self, Channel: 'CChan') -> "bool":
        return _znc_core.CModules_OnTimerAutoJoin(self, Channel)

    def OnAddNetwork(self, Network: 'CIRCNetwork', sErrorRet: 'CString &') -> "bool":
        return _znc_core.CModules_OnAddNetwork(self, Network, sErrorRet)

    def OnDeleteNetwork(self, Network: 'CIRCNetwork') -> "bool":
        return _znc_core.CModules_OnDeleteNetwork(self, Network)

    def OnSendToClient(self, sLine: 'CString &', Client: 'CClient') -> "bool":
        return _znc_core.CModules_OnSendToClient(self, sLine, Client)

    def OnSendToIRC(self, sLine: 'CString &') -> "bool":
        return _znc_core.CModules_OnSendToIRC(self, sLine)

    def OnServerCapAvailable(self, sCap: 'CString const &') -> "bool":
        return _znc_core.CModules_OnServerCapAvailable(self, sCap)

    def OnServerCapResult(self, sCap: 'CString const &', bSuccess: 'bool') -> "bool":
        return _znc_core.CModules_OnServerCapResult(self, sCap, bSuccess)

    def FindModule(self, sModule: 'CString const &') -> "CModule *":
        return _znc_core.CModules_FindModule(self, sModule)

    def LoadModule(self, sModule: 'CString const &', sArgs: 'CString const &', eType: 'CModInfo::EModuleType', pUser: 'CUser', pNetwork: 'CIRCNetwork', sRetMsg: 'CString &') -> "bool":
        return _znc_core.CModules_LoadModule(self, sModule, sArgs, eType, pUser, pNetwork, sRetMsg)

    def UnloadModule(self, *args) -> "bool":
        return _znc_core.CModules_UnloadModule(self, *args)

    def ReloadModule(self, sModule: 'CString const &', sArgs: 'CString const &', pUser: 'CUser', pNetwork: 'CIRCNetwork', sRetMsg: 'CString &') -> "bool":
        return _znc_core.CModules_ReloadModule(self, sModule, sArgs, pUser, pNetwork, sRetMsg)
    __swig_getmethods__["GetModInfo"] = lambda x: _znc_core.CModules_GetModInfo
    if _newclass:
        GetModInfo = staticmethod(_znc_core.CModules_GetModInfo)
    __swig_getmethods__["GetModPathInfo"] = lambda x: _znc_core.CModules_GetModPathInfo
    if _newclass:
        GetModPathInfo = staticmethod(_znc_core.CModules_GetModPathInfo)
    __swig_getmethods__["GetAvailableMods"] = lambda x: _znc_core.CModules_GetAvailableMods
    if _newclass:
        GetAvailableMods = staticmethod(_znc_core.CModules_GetAvailableMods)
    __swig_getmethods__["GetDefaultMods"] = lambda x: _znc_core.CModules_GetDefaultMods
    if _newclass:
        GetDefaultMods = staticmethod(_znc_core.CModules_GetDefaultMods)
    __swig_getmethods__["FindModPath"] = lambda x: _znc_core.CModules_FindModPath
    if _newclass:
        FindModPath = staticmethod(_znc_core.CModules_FindModPath)
    __swig_getmethods__["GetModDirs"] = lambda x: _znc_core.CModules_GetModDirs
    if _newclass:
        GetModDirs = staticmethod(_znc_core.CModules_GetModDirs)

    def OnAddUser(self, User: 'CUser', sErrorRet: 'CString &') -> "bool":
        return _znc_core.CModules_OnAddUser(self, User, sErrorRet)

    def OnDeleteUser(self, User: 'CUser') -> "bool":
        return _znc_core.CModules_OnDeleteUser(self, User)

    def OnClientConnect(self, pSock: 'CZNCSock', sHost: 'CString const &', uPort: 'unsigned short') -> "bool":
        return _znc_core.CModules_OnClientConnect(self, pSock, sHost, uPort)

    def OnLoginAttempt(self, Auth: 'std::shared_ptr< CAuthBase >') -> "bool":
        return _znc_core.CModules_OnLoginAttempt(self, Auth)

    def OnFailedLogin(self, sUsername: 'CString const &', sRemoteIP: 'CString const &') -> "bool":
        return _znc_core.CModules_OnFailedLogin(self, sUsername, sRemoteIP)

    def OnUnknownUserRaw(self, pClient: 'CClient', sLine: 'CString &') -> "bool":
        return _znc_core.CModules_OnUnknownUserRaw(self, pClient, sLine)

    def OnClientCapLs(self, pClient: 'CClient', ssCaps: 'SCString') -> "bool":
        return _znc_core.CModules_OnClientCapLs(self, pClient, ssCaps)

    def IsClientCapSupported(self, pClient: 'CClient', sCap: 'CString const &', bState: 'bool') -> "bool":
        return _znc_core.CModules_IsClientCapSupported(self, pClient, sCap, bState)

    def OnClientCapRequest(self, pClient: 'CClient', sCap: 'CString const &', bState: 'bool') -> "bool":
        return _znc_core.CModules_OnClientCapRequest(self, pClient, sCap, bState)

    def OnModuleLoading(self, sModName: 'CString const &', sArgs: 'CString const &', eType: 'CModInfo::EModuleType', bSuccess: 'bool &', sRetMsg: 'CString &') -> "bool":
        return _znc_core.CModules_OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg)

    def OnModuleUnloading(self, pModule: 'CModule', bSuccess: 'bool &', sRetMsg: 'CString &') -> "bool":
        return _znc_core.CModules_OnModuleUnloading(self, pModule, bSuccess, sRetMsg)

    def OnGetModInfo(self, ModInfo: 'CModInfo', sModule: 'CString const &', bSuccess: 'bool &', sRetMsg: 'CString &') -> "bool":
        return _znc_core.CModules_OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg)

    def OnGetAvailableMods(self, ssMods: 'SModInfo', eType: 'CModInfo::EModuleType') -> "bool":
        return _znc_core.CModules_OnGetAvailableMods(self, ssMods, eType)

    def removeModule(self, p: 'CModule') -> "bool":
        return _znc_core.CModules_removeModule(self, p)
CModules_swigregister = _znc_core.CModules_swigregister
CModules_swigregister(CModules)

def CModules_GetModInfo(ModInfo: 'CModInfo', sModule: 'CString const &', sRetMsg: 'CString &') -> "bool":
    return _znc_core.CModules_GetModInfo(ModInfo, sModule, sRetMsg)
CModules_GetModInfo = _znc_core.CModules_GetModInfo

def CModules_GetModPathInfo(ModInfo: 'CModInfo', sModule: 'CString const &', sModPath: 'CString const &', sRetMsg: 'CString &') -> "bool":
    return _znc_core.CModules_GetModPathInfo(ModInfo, sModule, sModPath, sRetMsg)
CModules_GetModPathInfo = _znc_core.CModules_GetModPathInfo

def CModules_GetAvailableMods(*args) -> "void":
    return _znc_core.CModules_GetAvailableMods(*args)
CModules_GetAvailableMods = _znc_core.CModules_GetAvailableMods

def CModules_GetDefaultMods(*args) -> "void":
    return _znc_core.CModules_GetDefaultMods(*args)
CModules_GetDefaultMods = _znc_core.CModules_GetDefaultMods

def CModules_FindModPath(sModule: 'CString const &', sModPath: 'CString &', sDataPath: 'CString &') -> "bool":
    return _znc_core.CModules_FindModPath(sModule, sModPath, sDataPath)
CModules_FindModPath = _znc_core.CModules_FindModPath

def CModules_GetModDirs() -> "CModules::ModDirList":
    return _znc_core.CModules_GetModDirs()
CModules_GetModDirs = _znc_core.CModules_GetModDirs

class CNick(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CNick, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CNick, name)

    def __init__(self, *args):
        this = _znc_core.new_CNick(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CNick
    __del__ = lambda self: None

    def Reset(self) -> "void":
        return _znc_core.CNick_Reset(self)

    def Parse(self, sNickMask: 'CString const &') -> "void":
        return _znc_core.CNick_Parse(self, sNickMask)

    def GetHostMask(self) -> "CString":
        return _znc_core.CNick_GetHostMask(self)

    def GetCommonChans(self, vChans: 'VChannels', pNetwork: 'CIRCNetwork') -> "size_t":
        return _znc_core.CNick_GetCommonChans(self, vChans, pNetwork)

    def NickEquals(self, nickname: 'CString const &') -> "bool":
        return _znc_core.CNick_NickEquals(self, nickname)

    def SetNetwork(self, pNetwork: 'CIRCNetwork') -> "void":
        return _znc_core.CNick_SetNetwork(self, pNetwork)

    def SetNick(self, s: 'CString const &') -> "void":
        return _znc_core.CNick_SetNick(self, s)

    def SetIdent(self, s: 'CString const &') -> "void":
        return _znc_core.CNick_SetIdent(self, s)

    def SetHost(self, s: 'CString const &') -> "void":
        return _znc_core.CNick_SetHost(self, s)

    def AddPerm(self, uPerm: 'unsigned char') -> "bool":
        return _znc_core.CNick_AddPerm(self, uPerm)

    def RemPerm(self, uPerm: 'unsigned char') -> "bool":
        return _znc_core.CNick_RemPerm(self, uPerm)

    def GetPermStr(self) -> "CString":
        return _znc_core.CNick_GetPermStr(self)

    def GetPermChar(self) -> "unsigned char":
        return _znc_core.CNick_GetPermChar(self)

    def HasPerm(self, uPerm: 'unsigned char') -> "bool":
        return _znc_core.CNick_HasPerm(self, uPerm)

    def GetNick(self) -> "CString const &":
        return _znc_core.CNick_GetNick(self)

    def GetIdent(self) -> "CString const &":
        return _znc_core.CNick_GetIdent(self)

    def GetHost(self) -> "CString const &":
        return _znc_core.CNick_GetHost(self)

    def GetNickMask(self) -> "CString":
        return _znc_core.CNick_GetNickMask(self)

    def Clone(self, SourceNick: 'CNick') -> "void":
        return _znc_core.CNick_Clone(self, SourceNick)

    def __str__(self) -> "CString":
        return _znc_core.CNick___str__(self)

    def __repr__(self) -> "CString":
        return _znc_core.CNick___repr__(self)
CNick_swigregister = _znc_core.CNick_swigregister
CNick_swigregister(CNick)

class CChan(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CChan, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CChan, name)
    Voice = _znc_core.CChan_Voice
    HalfOp = _znc_core.CChan_HalfOp
    Op = _znc_core.CChan_Op
    Admin = _znc_core.CChan_Admin
    Owner = _znc_core.CChan_Owner
    M_Private = _znc_core.CChan_M_Private
    M_Secret = _znc_core.CChan_M_Secret
    M_Moderated = _znc_core.CChan_M_Moderated
    M_InviteOnly = _znc_core.CChan_M_InviteOnly
    M_NoMessages = _znc_core.CChan_M_NoMessages
    M_OpTopic = _znc_core.CChan_M_OpTopic
    M_Limit = _znc_core.CChan_M_Limit
    M_Key = _znc_core.CChan_M_Key
    M_Op = _znc_core.CChan_M_Op
    M_Voice = _znc_core.CChan_M_Voice
    M_Ban = _znc_core.CChan_M_Ban
    M_Except = _znc_core.CChan_M_Except

    def __init__(self, sName: 'CString const &', pNetwork: 'CIRCNetwork', bInConfig: 'bool', pConfig: 'CConfig'=None):
        this = _znc_core.new_CChan(sName, pNetwork, bInConfig, pConfig)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CChan
    __del__ = lambda self: None

    def Reset(self) -> "void":
        return _znc_core.CChan_Reset(self)

    def ToConfig(self) -> "CConfig":
        return _znc_core.CChan_ToConfig(self)

    def Clone(self, chan: 'CChan') -> "void":
        return _znc_core.CChan_Clone(self, chan)

    def Cycle(self) -> "void":
        return _znc_core.CChan_Cycle(self)

    def JoinUser(self, *args) -> "void":
        return _znc_core.CChan_JoinUser(self, *args)

    def AttachUser(self, pClient: 'CClient'=None) -> "void":
        return _znc_core.CChan_AttachUser(self, pClient)

    def DetachUser(self) -> "void":
        return _znc_core.CChan_DetachUser(self)

    def OnWho(self, sNick: 'CString const &', sIdent: 'CString const &', sHost: 'CString const &') -> "void":
        return _znc_core.CChan_OnWho(self, sNick, sIdent, sHost)

    def SetModes(self, s: 'CString const &') -> "void":
        return _znc_core.CChan_SetModes(self, s)

    def ModeChange(self, sModes: 'CString const &', OpNick: 'CNick'=None) -> "void":
        return _znc_core.CChan_ModeChange(self, sModes, OpNick)

    def AddMode(self, uMode: 'unsigned char', sArg: 'CString const &') -> "bool":
        return _znc_core.CChan_AddMode(self, uMode, sArg)

    def RemMode(self, uMode: 'unsigned char') -> "bool":
        return _znc_core.CChan_RemMode(self, uMode)

    def GetModeString(self) -> "CString":
        return _znc_core.CChan_GetModeString(self)

    def GetModeForNames(self) -> "CString":
        return _znc_core.CChan_GetModeForNames(self)

    def ClearNicks(self) -> "void":
        return _znc_core.CChan_ClearNicks(self)

    def FindNick(self, *args) -> "CNick *":
        return _znc_core.CChan_FindNick(self, *args)

    def AddNicks(self, sNicks: 'CString const &') -> "int":
        return _znc_core.CChan_AddNicks(self, sNicks)

    def AddNick(self, sNick: 'CString const &') -> "bool":
        return _znc_core.CChan_AddNick(self, sNick)

    def RemNick(self, sNick: 'CString const &') -> "bool":
        return _znc_core.CChan_RemNick(self, sNick)

    def ChangeNick(self, sOldNick: 'CString const &', sNewNick: 'CString const &') -> "bool":
        return _znc_core.CChan_ChangeNick(self, sOldNick, sNewNick)

    def GetBuffer(self) -> "CBuffer const &":
        return _znc_core.CChan_GetBuffer(self)

    def GetBufferCount(self) -> "unsigned int":
        return _znc_core.CChan_GetBufferCount(self)

    def SetBufferCount(self, u: 'unsigned int', bForce: 'bool'=False) -> "bool":
        return _znc_core.CChan_SetBufferCount(self, u, bForce)

    def InheritBufferCount(self, u: 'unsigned int', bForce: 'bool'=False) -> "void":
        return _znc_core.CChan_InheritBufferCount(self, u, bForce)

    def AddBuffer(self, *args) -> "size_t":
        return _znc_core.CChan_AddBuffer(self, *args)

    def ClearBuffer(self) -> "void":
        return _znc_core.CChan_ClearBuffer(self)

    def SendBuffer(self, *args) -> "void":
        return _znc_core.CChan_SendBuffer(self, *args)

    def GetPermStr(self) -> "CString":
        return _znc_core.CChan_GetPermStr(self)

    def HasPerm(self, uPerm: 'unsigned char') -> "bool":
        return _znc_core.CChan_HasPerm(self, uPerm)

    def AddPerm(self, uPerm: 'unsigned char') -> "bool":
        return _znc_core.CChan_AddPerm(self, uPerm)

    def RemPerm(self, uPerm: 'unsigned char') -> "bool":
        return _znc_core.CChan_RemPerm(self, uPerm)

    def SetModeKnown(self, b: 'bool') -> "void":
        return _znc_core.CChan_SetModeKnown(self, b)

    def SetIsOn(self, b: 'bool') -> "void":
        return _znc_core.CChan_SetIsOn(self, b)

    def SetKey(self, s: 'CString const &') -> "void":
        return _znc_core.CChan_SetKey(self, s)

    def SetTopic(self, s: 'CString const &') -> "void":
        return _znc_core.CChan_SetTopic(self, s)

    def SetTopicOwner(self, s: 'CString const &') -> "void":
        return _znc_core.CChan_SetTopicOwner(self, s)

    def SetTopicDate(self, u: 'unsigned long') -> "void":
        return _znc_core.CChan_SetTopicDate(self, u)

    def SetDefaultModes(self, s: 'CString const &') -> "void":
        return _znc_core.CChan_SetDefaultModes(self, s)

    def SetAutoClearChanBuffer(self, b: 'bool') -> "void":
        return _znc_core.CChan_SetAutoClearChanBuffer(self, b)

    def InheritAutoClearChanBuffer(self, b: 'bool') -> "void":
        return _znc_core.CChan_InheritAutoClearChanBuffer(self, b)

    def SetDetached(self, b: 'bool'=True) -> "void":
        return _znc_core.CChan_SetDetached(self, b)

    def SetInConfig(self, b: 'bool') -> "void":
        return _znc_core.CChan_SetInConfig(self, b)

    def SetCreationDate(self, u: 'unsigned long') -> "void":
        return _znc_core.CChan_SetCreationDate(self, u)

    def Disable(self) -> "void":
        return _znc_core.CChan_Disable(self)

    def Enable(self) -> "void":
        return _znc_core.CChan_Enable(self)

    def IncJoinTries(self) -> "void":
        return _znc_core.CChan_IncJoinTries(self)

    def ResetJoinTries(self) -> "void":
        return _znc_core.CChan_ResetJoinTries(self)

    def IsModeKnown(self) -> "bool":
        return _znc_core.CChan_IsModeKnown(self)

    def HasMode(self, uMode: 'unsigned char') -> "bool":
        return _znc_core.CChan_HasMode(self, uMode)

    def GetOptions(self) -> "CString":
        return _znc_core.CChan_GetOptions(self)

    def GetModeArg(self, *args) -> "CString":
        return _znc_core.CChan_GetModeArg(self, *args)

    def GetPermCounts(self) -> "std::map< char,unsigned int,std::less< char >,std::allocator< std::pair< char const,unsigned int > > >":
        return _znc_core.CChan_GetPermCounts(self)

    def IsOn(self) -> "bool":
        return _znc_core.CChan_IsOn(self)

    def GetName(self) -> "CString const &":
        return _znc_core.CChan_GetName(self)

    def GetModes(self) -> "std::map< unsigned char,CString,std::less< unsigned char >,std::allocator< std::pair< unsigned char const,CString > > > const &":
        return _znc_core.CChan_GetModes(self)

    def GetKey(self) -> "CString const &":
        return _znc_core.CChan_GetKey(self)

    def GetTopic(self) -> "CString const &":
        return _znc_core.CChan_GetTopic(self)

    def GetTopicOwner(self) -> "CString const &":
        return _znc_core.CChan_GetTopicOwner(self)

    def GetTopicDate(self) -> "unsigned long":
        return _znc_core.CChan_GetTopicDate(self)

    def GetDefaultModes(self) -> "CString const &":
        return _znc_core.CChan_GetDefaultModes(self)

    def GetNicks(self) -> "std::map< CString,CNick,std::less< CString >,std::allocator< std::pair< CString const,CNick > > > const &":
        return _znc_core.CChan_GetNicks(self)

    def GetNickCount(self) -> "size_t":
        return _znc_core.CChan_GetNickCount(self)

    def AutoClearChanBuffer(self) -> "bool":
        return _znc_core.CChan_AutoClearChanBuffer(self)

    def IsDetached(self) -> "bool":
        return _znc_core.CChan_IsDetached(self)

    def InConfig(self) -> "bool":
        return _znc_core.CChan_InConfig(self)

    def GetCreationDate(self) -> "unsigned long":
        return _znc_core.CChan_GetCreationDate(self)

    def IsDisabled(self) -> "bool":
        return _znc_core.CChan_IsDisabled(self)

    def GetJoinTries(self) -> "unsigned int":
        return _znc_core.CChan_GetJoinTries(self)

    def HasBufferCountSet(self) -> "bool":
        return _znc_core.CChan_HasBufferCountSet(self)

    def HasAutoClearChanBufferSet(self) -> "bool":
        return _znc_core.CChan_HasAutoClearChanBufferSet(self)

    def __str__(self) -> "CString":
        return _znc_core.CChan___str__(self)

    def __repr__(self) -> "CString":
        return _znc_core.CChan___repr__(self)

    def GetNicks_(self) -> "std::map< CString,CNick,std::less< CString >,std::allocator< std::pair< CString const,CNick > > >":
        return _znc_core.CChan_GetNicks_(self)
CChan_swigregister = _znc_core.CChan_swigregister
CChan_swigregister(CChan)

class CUser(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CUser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CUser, name)

    def __init__(self, sUserName: 'CString const &'):
        this = _znc_core.new_CUser(sUserName)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CUser
    __del__ = lambda self: None

    def ParseConfig(self, Config: 'CConfig', sError: 'CString &') -> "bool":
        return _znc_core.CUser_ParseConfig(self, Config, sError)
    HASH_NONE = _znc_core.CUser_HASH_NONE
    HASH_MD5 = _znc_core.CUser_HASH_MD5
    HASH_SHA256 = _znc_core.CUser_HASH_SHA256
    HASH_DEFAULT = _znc_core.CUser_HASH_DEFAULT
    __swig_getmethods__["SaltedHash"] = lambda x: _znc_core.CUser_SaltedHash
    if _newclass:
        SaltedHash = staticmethod(_znc_core.CUser_SaltedHash)

    def ToConfig(self) -> "CConfig":
        return _znc_core.CUser_ToConfig(self)

    def CheckPass(self, sPass: 'CString const &') -> "bool":
        return _znc_core.CUser_CheckPass(self, sPass)

    def AddAllowedHost(self, sHostMask: 'CString const &') -> "bool":
        return _znc_core.CUser_AddAllowedHost(self, sHostMask)

    def IsHostAllowed(self, sHostMask: 'CString const &') -> "bool":
        return _znc_core.CUser_IsHostAllowed(self, sHostMask)

    def IsValid(self, sErrMsg: 'CString &', bSkipPass: 'bool'=False) -> "bool":
        return _znc_core.CUser_IsValid(self, sErrMsg, bSkipPass)
    __swig_getmethods__["IsValidUserName"] = lambda x: _znc_core.CUser_IsValidUserName
    if _newclass:
        IsValidUserName = staticmethod(_znc_core.CUser_IsValidUserName)
    __swig_getmethods__["MakeCleanUserName"] = lambda x: _znc_core.CUser_MakeCleanUserName
    if _newclass:
        MakeCleanUserName = staticmethod(_znc_core.CUser_MakeCleanUserName)

    def GetModules(self, *args) -> "CModules const &":
        return _znc_core.CUser_GetModules(self, *args)

    def DeleteNetwork(self, sNetwork: 'CString const &') -> "bool":
        return _znc_core.CUser_DeleteNetwork(self, sNetwork)

    def AddNetwork(self, *args) -> "bool":
        return _znc_core.CUser_AddNetwork(self, *args)

    def RemoveNetwork(self, pNetwork: 'CIRCNetwork') -> "void":
        return _znc_core.CUser_RemoveNetwork(self, pNetwork)

    def FindNetwork(self, sNetwork: 'CString const &') -> "CIRCNetwork *":
        return _znc_core.CUser_FindNetwork(self, sNetwork)

    def GetNetworks(self) -> "std::vector< CIRCNetwork *,std::allocator< CIRCNetwork * > > const &":
        return _znc_core.CUser_GetNetworks(self)

    def HasSpaceForNewNetwork(self) -> "bool":
        return _znc_core.CUser_HasSpaceForNewNetwork(self)

    def PutUser(self, sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CUser_PutUser(self, sLine, pClient, pSkipClient)

    def PutAllUser(self, sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CUser_PutAllUser(self, sLine, pClient, pSkipClient)

    def PutStatus(self, sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CUser_PutStatus(self, sLine, pClient, pSkipClient)

    def PutStatusNotice(self, sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CUser_PutStatusNotice(self, sLine, pClient, pSkipClient)

    def PutModule(self, sModule: 'CString const &', sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CUser_PutModule(self, sModule, sLine, pClient, pSkipClient)

    def PutModNotice(self, sModule: 'CString const &', sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CUser_PutModNotice(self, sModule, sLine, pClient, pSkipClient)

    def IsUserAttached(self) -> "bool":
        return _znc_core.CUser_IsUserAttached(self)

    def UserConnected(self, pClient: 'CClient') -> "void":
        return _znc_core.CUser_UserConnected(self, pClient)

    def UserDisconnected(self, pClient: 'CClient') -> "void":
        return _znc_core.CUser_UserDisconnected(self, pClient)

    def GetLocalDCCIP(self) -> "CString":
        return _znc_core.CUser_GetLocalDCCIP(self)

    def ExpandString(self, *args) -> "CString &":
        return _znc_core.CUser_ExpandString(self, *args)

    def AddTimestamp(self, *args) -> "CString":
        return _znc_core.CUser_AddTimestamp(self, *args)

    def CloneNetworks(self, User: 'CUser') -> "void":
        return _znc_core.CUser_CloneNetworks(self, User)

    def Clone(self, User: 'CUser', sErrorRet: 'CString &', bCloneNetworks: 'bool'=True) -> "bool":
        return _znc_core.CUser_Clone(self, User, sErrorRet, bCloneNetworks)

    def BounceAllClients(self) -> "void":
        return _znc_core.CUser_BounceAllClients(self)

    def AddBytesRead(self, u: 'unsigned long long') -> "void":
        return _znc_core.CUser_AddBytesRead(self, u)

    def AddBytesWritten(self, u: 'unsigned long long') -> "void":
        return _znc_core.CUser_AddBytesWritten(self, u)

    def SetNick(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetNick(self, s)

    def SetAltNick(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetAltNick(self, s)

    def SetIdent(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetIdent(self, s)

    def SetRealName(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetRealName(self, s)

    def SetBindHost(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetBindHost(self, s)

    def SetDCCBindHost(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetDCCBindHost(self, s)

    def SetPass(self, *args) -> "void":
        return _znc_core.CUser_SetPass(self, *args)

    def SetMultiClients(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetMultiClients(self, b)

    def SetDenyLoadMod(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetDenyLoadMod(self, b)

    def SetAdmin(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetAdmin(self, b)

    def SetDenySetBindHost(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetDenySetBindHost(self, b)

    def SetStatusPrefix(self, s: 'CString const &') -> "bool":
        return _znc_core.CUser_SetStatusPrefix(self, s)

    def SetDefaultChanModes(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetDefaultChanModes(self, s)

    def SetClientEncoding(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetClientEncoding(self, s)

    def SetQuitMsg(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetQuitMsg(self, s)

    def AddCTCPReply(self, sCTCP: 'CString const &', sReply: 'CString const &') -> "bool":
        return _znc_core.CUser_AddCTCPReply(self, sCTCP, sReply)

    def DelCTCPReply(self, sCTCP: 'CString const &') -> "bool":
        return _znc_core.CUser_DelCTCPReply(self, sCTCP)

    def SetBufferCount(self, u: 'unsigned int', bForce: 'bool'=False) -> "bool":
        return _znc_core.CUser_SetBufferCount(self, u, bForce)

    def SetAutoClearChanBuffer(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetAutoClearChanBuffer(self, b)

    def SetAutoClearQueryBuffer(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetAutoClearQueryBuffer(self, b)

    def SetBeingDeleted(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetBeingDeleted(self, b)

    def SetTimestampFormat(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetTimestampFormat(self, s)

    def SetTimestampAppend(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetTimestampAppend(self, b)

    def SetTimestampPrepend(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetTimestampPrepend(self, b)

    def SetTimezone(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetTimezone(self, s)

    def SetJoinTries(self, i: 'unsigned int') -> "void":
        return _znc_core.CUser_SetJoinTries(self, i)

    def SetMaxJoins(self, i: 'unsigned int') -> "void":
        return _znc_core.CUser_SetMaxJoins(self, i)

    def SetSkinName(self, s: 'CString const &') -> "void":
        return _znc_core.CUser_SetSkinName(self, s)

    def SetMaxNetworks(self, i: 'unsigned int') -> "void":
        return _znc_core.CUser_SetMaxNetworks(self, i)

    def SetMaxQueryBuffers(self, i: 'unsigned int') -> "void":
        return _znc_core.CUser_SetMaxQueryBuffers(self, i)

    def GetUserClients(self) -> "std::vector< CClient *,std::allocator< CClient * > > const &":
        return _znc_core.CUser_GetUserClients(self)

    def GetAllClients(self) -> "std::vector< CClient *,std::allocator< CClient * > >":
        return _znc_core.CUser_GetAllClients(self)

    def GetUserName(self) -> "CString const &":
        return _znc_core.CUser_GetUserName(self)

    def GetCleanUserName(self) -> "CString const &":
        return _znc_core.CUser_GetCleanUserName(self)

    def GetNick(self, bAllowDefault: 'bool'=True) -> "CString const &":
        return _znc_core.CUser_GetNick(self, bAllowDefault)

    def GetAltNick(self, bAllowDefault: 'bool'=True) -> "CString const &":
        return _znc_core.CUser_GetAltNick(self, bAllowDefault)

    def GetIdent(self, bAllowDefault: 'bool'=True) -> "CString const &":
        return _znc_core.CUser_GetIdent(self, bAllowDefault)

    def GetRealName(self) -> "CString const &":
        return _znc_core.CUser_GetRealName(self)

    def GetBindHost(self) -> "CString const &":
        return _znc_core.CUser_GetBindHost(self)

    def GetDCCBindHost(self) -> "CString const &":
        return _znc_core.CUser_GetDCCBindHost(self)

    def GetPass(self) -> "CString const &":
        return _znc_core.CUser_GetPass(self)

    def GetPassHashType(self) -> "CUser::eHashType":
        return _znc_core.CUser_GetPassHashType(self)

    def GetPassSalt(self) -> "CString const &":
        return _znc_core.CUser_GetPassSalt(self)

    def GetAllowedHosts(self) -> "std::set< CString,std::less< CString >,std::allocator< CString > > const &":
        return _znc_core.CUser_GetAllowedHosts(self)

    def GetTimestampFormat(self) -> "CString const &":
        return _znc_core.CUser_GetTimestampFormat(self)

    def GetClientEncoding(self) -> "CString const &":
        return _znc_core.CUser_GetClientEncoding(self)

    def GetTimestampAppend(self) -> "bool":
        return _znc_core.CUser_GetTimestampAppend(self)

    def GetTimestampPrepend(self) -> "bool":
        return _znc_core.CUser_GetTimestampPrepend(self)

    def GetUserPath(self) -> "CString const &":
        return _znc_core.CUser_GetUserPath(self)

    def DenyLoadMod(self) -> "bool":
        return _znc_core.CUser_DenyLoadMod(self)

    def IsAdmin(self) -> "bool":
        return _znc_core.CUser_IsAdmin(self)

    def DenySetBindHost(self) -> "bool":
        return _znc_core.CUser_DenySetBindHost(self)

    def MultiClients(self) -> "bool":
        return _znc_core.CUser_MultiClients(self)

    def GetStatusPrefix(self) -> "CString const &":
        return _znc_core.CUser_GetStatusPrefix(self)

    def GetDefaultChanModes(self) -> "CString const &":
        return _znc_core.CUser_GetDefaultChanModes(self)

    def GetQuitMsg(self) -> "CString":
        return _znc_core.CUser_GetQuitMsg(self)

    def GetCTCPReplies(self) -> "MCString const &":
        return _znc_core.CUser_GetCTCPReplies(self)

    def GetBufferCount(self) -> "unsigned int":
        return _znc_core.CUser_GetBufferCount(self)

    def AutoClearChanBuffer(self) -> "bool":
        return _znc_core.CUser_AutoClearChanBuffer(self)

    def AutoClearQueryBuffer(self) -> "bool":
        return _znc_core.CUser_AutoClearQueryBuffer(self)

    def IsBeingDeleted(self) -> "bool":
        return _znc_core.CUser_IsBeingDeleted(self)

    def GetTimezone(self) -> "CString":
        return _znc_core.CUser_GetTimezone(self)

    def BytesRead(self) -> "unsigned long long":
        return _znc_core.CUser_BytesRead(self)

    def BytesWritten(self) -> "unsigned long long":
        return _znc_core.CUser_BytesWritten(self)

    def JoinTries(self) -> "unsigned int":
        return _znc_core.CUser_JoinTries(self)

    def MaxJoins(self) -> "unsigned int":
        return _znc_core.CUser_MaxJoins(self)

    def GetSkinName(self) -> "CString":
        return _znc_core.CUser_GetSkinName(self)

    def MaxNetworks(self) -> "unsigned int":
        return _znc_core.CUser_MaxNetworks(self)

    def MaxQueryBuffers(self) -> "unsigned int":
        return _znc_core.CUser_MaxQueryBuffers(self)

    def __str__(self) -> "CString":
        return _znc_core.CUser___str__(self)

    def __repr__(self) -> "CString":
        return _znc_core.CUser___repr__(self)

    def GetNetworks_(self) -> "std::vector< CIRCNetwork *,std::allocator< CIRCNetwork * > >":
        return _znc_core.CUser_GetNetworks_(self)
CUser_swigregister = _znc_core.CUser_swigregister
CUser_swigregister(CUser)

def CUser_SaltedHash(sPass: 'CString const &', sSalt: 'CString const &') -> "CString":
    return _znc_core.CUser_SaltedHash(sPass, sSalt)
CUser_SaltedHash = _znc_core.CUser_SaltedHash

def CUser_IsValidUserName(sUserName: 'CString const &') -> "bool":
    return _znc_core.CUser_IsValidUserName(sUserName)
CUser_IsValidUserName = _znc_core.CUser_IsValidUserName

def CUser_MakeCleanUserName(sUserName: 'CString const &') -> "CString":
    return _znc_core.CUser_MakeCleanUserName(sUserName)
CUser_MakeCleanUserName = _znc_core.CUser_MakeCleanUserName

class CIRCNetwork(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CIRCNetwork, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CIRCNetwork, name)
    __swig_getmethods__["IsValidNetwork"] = lambda x: _znc_core.CIRCNetwork_IsValidNetwork
    if _newclass:
        IsValidNetwork = staticmethod(_znc_core.CIRCNetwork_IsValidNetwork)

    def __init__(self, *args):
        this = _znc_core.new_CIRCNetwork(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CIRCNetwork
    __del__ = lambda self: None
    JOIN_FREQUENCY = _znc_core.CIRCNetwork_JOIN_FREQUENCY
    PING_FREQUENCY = _znc_core.CIRCNetwork_PING_FREQUENCY
    PING_SLACK = _znc_core.CIRCNetwork_PING_SLACK
    NO_TRAFFIC_TIMEOUT = _znc_core.CIRCNetwork_NO_TRAFFIC_TIMEOUT

    def Clone(self, Network: 'CIRCNetwork', bCloneName: 'bool'=True) -> "void":
        return _znc_core.CIRCNetwork_Clone(self, Network, bCloneName)

    def GetNetworkPath(self) -> "CString":
        return _znc_core.CIRCNetwork_GetNetworkPath(self)

    def DelServers(self) -> "void":
        return _znc_core.CIRCNetwork_DelServers(self)

    def ParseConfig(self, pConfig: 'CConfig', sError: 'CString &', bUpgrade: 'bool'=False) -> "bool":
        return _znc_core.CIRCNetwork_ParseConfig(self, pConfig, sError, bUpgrade)

    def ToConfig(self) -> "CConfig":
        return _znc_core.CIRCNetwork_ToConfig(self)

    def BounceAllClients(self) -> "void":
        return _znc_core.CIRCNetwork_BounceAllClients(self)

    def IsUserAttached(self) -> "bool":
        return _znc_core.CIRCNetwork_IsUserAttached(self)

    def IsUserOnline(self) -> "bool":
        return _znc_core.CIRCNetwork_IsUserOnline(self)

    def ClientConnected(self, pClient: 'CClient') -> "void":
        return _znc_core.CIRCNetwork_ClientConnected(self, pClient)

    def ClientDisconnected(self, pClient: 'CClient') -> "void":
        return _znc_core.CIRCNetwork_ClientDisconnected(self, pClient)

    def GetUser(self) -> "CUser *":
        return _znc_core.CIRCNetwork_GetUser(self)

    def GetName(self) -> "CString const &":
        return _znc_core.CIRCNetwork_GetName(self)

    def IsNetworkAttached(self) -> "bool":
        return _znc_core.CIRCNetwork_IsNetworkAttached(self)

    def GetClients(self) -> "std::vector< CClient *,std::allocator< CClient * > > const &":
        return _znc_core.CIRCNetwork_GetClients(self)

    def FindClients(self, sIdentifier: 'CString const &') -> "std::vector< CClient *,std::allocator< CClient * > >":
        return _znc_core.CIRCNetwork_FindClients(self, sIdentifier)

    def SetUser(self, pUser: 'CUser') -> "void":
        return _znc_core.CIRCNetwork_SetUser(self, pUser)

    def SetName(self, sName: 'CString const &') -> "bool":
        return _znc_core.CIRCNetwork_SetName(self, sName)

    def GetModules(self, *args) -> "CModules const &":
        return _znc_core.CIRCNetwork_GetModules(self, *args)

    def PutUser(self, sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CIRCNetwork_PutUser(self, sLine, pClient, pSkipClient)

    def PutStatus(self, sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CIRCNetwork_PutStatus(self, sLine, pClient, pSkipClient)

    def PutModule(self, sModule: 'CString const &', sLine: 'CString const &', pClient: 'CClient'=None, pSkipClient: 'CClient'=None) -> "bool":
        return _znc_core.CIRCNetwork_PutModule(self, sModule, sLine, pClient, pSkipClient)

    def GetChans(self) -> "std::vector< CChan *,std::allocator< CChan * > > const &":
        return _znc_core.CIRCNetwork_GetChans(self)

    def FindChan(self, sName: 'CString') -> "CChan *":
        return _znc_core.CIRCNetwork_FindChan(self, sName)

    def FindChans(self, sWild: 'CString const &') -> "std::vector< CChan *,std::allocator< CChan * > >":
        return _znc_core.CIRCNetwork_FindChans(self, sWild)

    def AddChan(self, *args) -> "bool":
        return _znc_core.CIRCNetwork_AddChan(self, *args)

    def DelChan(self, sName: 'CString const &') -> "bool":
        return _znc_core.CIRCNetwork_DelChan(self, sName)

    def JoinChans(self, *args) -> "void":
        return _znc_core.CIRCNetwork_JoinChans(self, *args)

    def GetQueries(self) -> "std::vector< CQuery *,std::allocator< CQuery * > > const &":
        return _znc_core.CIRCNetwork_GetQueries(self)

    def FindQuery(self, sName: 'CString const &') -> "CQuery *":
        return _znc_core.CIRCNetwork_FindQuery(self, sName)

    def FindQueries(self, sWild: 'CString const &') -> "std::vector< CQuery *,std::allocator< CQuery * > >":
        return _znc_core.CIRCNetwork_FindQueries(self, sWild)

    def AddQuery(self, sName: 'CString const &') -> "CQuery *":
        return _znc_core.CIRCNetwork_AddQuery(self, sName)

    def DelQuery(self, sName: 'CString const &') -> "bool":
        return _znc_core.CIRCNetwork_DelQuery(self, sName)

    def GetChanPrefixes(self) -> "CString const &":
        return _znc_core.CIRCNetwork_GetChanPrefixes(self)

    def SetChanPrefixes(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetChanPrefixes(self, s)

    def IsChan(self, sChan: 'CString const &') -> "bool":
        return _znc_core.CIRCNetwork_IsChan(self, sChan)

    def GetServers(self) -> "std::vector< CServer *,std::allocator< CServer * > > const &":
        return _znc_core.CIRCNetwork_GetServers(self)

    def HasServers(self) -> "bool":
        return _znc_core.CIRCNetwork_HasServers(self)

    def FindServer(self, sName: 'CString const &') -> "CServer *":
        return _znc_core.CIRCNetwork_FindServer(self, sName)

    def DelServer(self, sName: 'CString const &', uPort: 'unsigned short', sPass: 'CString const &') -> "bool":
        return _znc_core.CIRCNetwork_DelServer(self, sName, uPort, sPass)

    def AddServer(self, *args) -> "bool":
        return _znc_core.CIRCNetwork_AddServer(self, *args)

    def GetNextServer(self) -> "CServer *":
        return _znc_core.CIRCNetwork_GetNextServer(self)

    def GetCurrentServer(self) -> "CServer *":
        return _znc_core.CIRCNetwork_GetCurrentServer(self)

    def SetIRCServer(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetIRCServer(self, s)

    def SetNextServer(self, pServer: 'CServer') -> "bool":
        return _znc_core.CIRCNetwork_SetNextServer(self, pServer)

    def IsLastServer(self) -> "bool":
        return _znc_core.CIRCNetwork_IsLastServer(self)

    def GetTrustedFingerprints(self) -> "SCString const &":
        return _znc_core.CIRCNetwork_GetTrustedFingerprints(self)

    def AddTrustedFingerprint(self, sFP: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_AddTrustedFingerprint(self, sFP)

    def DelTrustedFingerprint(self, sFP: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_DelTrustedFingerprint(self, sFP)

    def SetIRCConnectEnabled(self, b: 'bool') -> "void":
        return _znc_core.CIRCNetwork_SetIRCConnectEnabled(self, b)

    def GetIRCConnectEnabled(self) -> "bool":
        return _znc_core.CIRCNetwork_GetIRCConnectEnabled(self)

    def GetIRCSock(self, *args) -> "CIRCSock const *":
        return _znc_core.CIRCNetwork_GetIRCSock(self, *args)

    def GetIRCServer(self) -> "CString const &":
        return _znc_core.CIRCNetwork_GetIRCServer(self)

    def GetIRCNick(self) -> "CNick const &":
        return _znc_core.CIRCNetwork_GetIRCNick(self)

    def SetIRCNick(self, n: 'CNick') -> "void":
        return _znc_core.CIRCNetwork_SetIRCNick(self, n)

    def GetCurNick(self) -> "CString":
        return _znc_core.CIRCNetwork_GetCurNick(self)

    def IsIRCAway(self) -> "bool":
        return _znc_core.CIRCNetwork_IsIRCAway(self)

    def SetIRCAway(self, b: 'bool') -> "void":
        return _znc_core.CIRCNetwork_SetIRCAway(self, b)

    def Connect(self) -> "bool":
        return _znc_core.CIRCNetwork_Connect(self)

    def IsIRCConnected(self) -> "bool":
        return _znc_core.CIRCNetwork_IsIRCConnected(self)

    def SetIRCSocket(self, pIRCSock: 'CIRCSock') -> "void":
        return _znc_core.CIRCNetwork_SetIRCSocket(self, pIRCSock)

    def IRCConnected(self) -> "void":
        return _znc_core.CIRCNetwork_IRCConnected(self)

    def IRCDisconnected(self) -> "void":
        return _znc_core.CIRCNetwork_IRCDisconnected(self)

    def CheckIRCConnect(self) -> "void":
        return _znc_core.CIRCNetwork_CheckIRCConnect(self)

    def PutIRC(self, sLine: 'CString const &') -> "bool":
        return _znc_core.CIRCNetwork_PutIRC(self, sLine)

    def AddRawBuffer(self, *args) -> "void":
        return _znc_core.CIRCNetwork_AddRawBuffer(self, *args)

    def UpdateRawBuffer(self, *args) -> "void":
        return _znc_core.CIRCNetwork_UpdateRawBuffer(self, *args)

    def UpdateExactRawBuffer(self, *args) -> "void":
        return _znc_core.CIRCNetwork_UpdateExactRawBuffer(self, *args)

    def ClearRawBuffer(self) -> "void":
        return _znc_core.CIRCNetwork_ClearRawBuffer(self)

    def AddMotdBuffer(self, *args) -> "void":
        return _znc_core.CIRCNetwork_AddMotdBuffer(self, *args)

    def UpdateMotdBuffer(self, *args) -> "void":
        return _znc_core.CIRCNetwork_UpdateMotdBuffer(self, *args)

    def ClearMotdBuffer(self) -> "void":
        return _znc_core.CIRCNetwork_ClearMotdBuffer(self)

    def AddNoticeBuffer(self, *args) -> "void":
        return _znc_core.CIRCNetwork_AddNoticeBuffer(self, *args)

    def UpdateNoticeBuffer(self, *args) -> "void":
        return _znc_core.CIRCNetwork_UpdateNoticeBuffer(self, *args)

    def ClearNoticeBuffer(self) -> "void":
        return _znc_core.CIRCNetwork_ClearNoticeBuffer(self)

    def GetNick(self, bAllowDefault: 'bool const'=True) -> "CString const &":
        return _znc_core.CIRCNetwork_GetNick(self, bAllowDefault)

    def GetAltNick(self, bAllowDefault: 'bool const'=True) -> "CString const &":
        return _znc_core.CIRCNetwork_GetAltNick(self, bAllowDefault)

    def GetIdent(self, bAllowDefault: 'bool const'=True) -> "CString const &":
        return _znc_core.CIRCNetwork_GetIdent(self, bAllowDefault)

    def GetRealName(self) -> "CString const &":
        return _znc_core.CIRCNetwork_GetRealName(self)

    def GetBindHost(self) -> "CString const &":
        return _znc_core.CIRCNetwork_GetBindHost(self)

    def GetEncoding(self) -> "CString const &":
        return _znc_core.CIRCNetwork_GetEncoding(self)

    def GetQuitMsg(self) -> "CString":
        return _znc_core.CIRCNetwork_GetQuitMsg(self)

    def SetNick(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetNick(self, s)

    def SetAltNick(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetAltNick(self, s)

    def SetIdent(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetIdent(self, s)

    def SetRealName(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetRealName(self, s)

    def SetBindHost(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetBindHost(self, s)

    def SetEncoding(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetEncoding(self, s)

    def SetQuitMsg(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCNetwork_SetQuitMsg(self, s)

    def GetFloodRate(self) -> "double":
        return _znc_core.CIRCNetwork_GetFloodRate(self)

    def GetFloodBurst(self) -> "unsigned short":
        return _znc_core.CIRCNetwork_GetFloodBurst(self)

    def SetFloodRate(self, fFloodRate: 'double') -> "void":
        return _znc_core.CIRCNetwork_SetFloodRate(self, fFloodRate)

    def SetFloodBurst(self, uFloodBurst: 'unsigned short') -> "void":
        return _znc_core.CIRCNetwork_SetFloodBurst(self, uFloodBurst)

    def GetJoinDelay(self) -> "unsigned short":
        return _znc_core.CIRCNetwork_GetJoinDelay(self)

    def SetJoinDelay(self, uJoinDelay: 'unsigned short') -> "void":
        return _znc_core.CIRCNetwork_SetJoinDelay(self, uJoinDelay)

    def ExpandString(self, *args) -> "CString &":
        return _znc_core.CIRCNetwork_ExpandString(self, *args)

    def __str__(self) -> "CString":
        return _znc_core.CIRCNetwork___str__(self)

    def __repr__(self) -> "CString":
        return _znc_core.CIRCNetwork___repr__(self)

    def GetChans_(self) -> "std::vector< CChan *,std::allocator< CChan * > >":
        return _znc_core.CIRCNetwork_GetChans_(self)
CIRCNetwork_swigregister = _znc_core.CIRCNetwork_swigregister
CIRCNetwork_swigregister(CIRCNetwork)

def CIRCNetwork_IsValidNetwork(sNetwork: 'CString const &') -> "bool":
    return _znc_core.CIRCNetwork_IsValidNetwork(sNetwork)
CIRCNetwork_IsValidNetwork = _znc_core.CIRCNetwork_IsValidNetwork

class CAuthBase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAuthBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAuthBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _znc_core.delete_CAuthBase
    __del__ = lambda self: None

    def SetLoginInfo(self, sUsername: 'CString const &', sPassword: 'CString const &', pSock: 'CZNCSock') -> "void":
        return _znc_core.CAuthBase_SetLoginInfo(self, sUsername, sPassword, pSock)

    def AcceptLogin(self, User: 'CUser') -> "void":
        return _znc_core.CAuthBase_AcceptLogin(self, User)

    def RefuseLogin(self, sReason: 'CString const &') -> "void":
        return _znc_core.CAuthBase_RefuseLogin(self, sReason)

    def GetUsername(self) -> "CString const &":
        return _znc_core.CAuthBase_GetUsername(self)

    def GetPassword(self) -> "CString const &":
        return _znc_core.CAuthBase_GetPassword(self)

    def GetSocket(self) -> "Csock *":
        return _znc_core.CAuthBase_GetSocket(self)

    def GetRemoteIP(self) -> "CString":
        return _znc_core.CAuthBase_GetRemoteIP(self)

    def Invalidate(self) -> "void":
        return _znc_core.CAuthBase_Invalidate(self)
CAuthBase_swigregister = _znc_core.CAuthBase_swigregister
CAuthBase_swigregister(CAuthBase)

class CClientAuth(CAuthBase):
    __swig_setmethods__ = {}
    for _s in [CAuthBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CClientAuth, name, value)
    __swig_getmethods__ = {}
    for _s in [CAuthBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CClientAuth, name)
    __repr__ = _swig_repr

    def __init__(self, pClient: 'CClient', sUsername: 'CString const &', sPassword: 'CString const &'):
        this = _znc_core.new_CClientAuth(pClient, sUsername, sPassword)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CClientAuth
    __del__ = lambda self: None

    def Invalidate(self) -> "void":
        return _znc_core.CClientAuth_Invalidate(self)

    def AcceptedLogin(self, User: 'CUser') -> "void":
        return _znc_core.CClientAuth_AcceptedLogin(self, User)

    def RefusedLogin(self, sReason: 'CString const &') -> "void":
        return _znc_core.CClientAuth_RefusedLogin(self, sReason)
CClientAuth_swigregister = _znc_core.CClientAuth_swigregister
CClientAuth_swigregister(CClientAuth)

class CClient(CIRCSocket):
    __swig_setmethods__ = {}
    for _s in [CIRCSocket]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CClient, name, value)
    __swig_getmethods__ = {}
    for _s in [CIRCSocket]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CClient, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CClient()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CClient
    __del__ = lambda self: None

    def SendRequiredPasswordNotice(self) -> "void":
        return _znc_core.CClient_SendRequiredPasswordNotice(self)

    def AcceptLogin(self, User: 'CUser') -> "void":
        return _znc_core.CClient_AcceptLogin(self, User)

    def RefuseLogin(self, sReason: 'CString const &') -> "void":
        return _znc_core.CClient_RefuseLogin(self, sReason)

    def GetNick(self, bAllowIRCNick: 'bool'=True) -> "CString":
        return _znc_core.CClient_GetNick(self, bAllowIRCNick)

    def GetNickMask(self) -> "CString":
        return _znc_core.CClient_GetNickMask(self)

    def GetIdentifier(self) -> "CString":
        return _znc_core.CClient_GetIdentifier(self)

    def HasNamesx(self) -> "bool":
        return _znc_core.CClient_HasNamesx(self)

    def HasUHNames(self) -> "bool":
        return _znc_core.CClient_HasUHNames(self)

    def IsAway(self) -> "bool":
        return _znc_core.CClient_IsAway(self)

    def HasServerTime(self) -> "bool":
        return _znc_core.CClient_HasServerTime(self)

    def HasBatch(self) -> "bool":
        return _znc_core.CClient_HasBatch(self)

    def HasSelfMessage(self) -> "bool":
        return _znc_core.CClient_HasSelfMessage(self)
    __swig_getmethods__["IsValidIdentifier"] = lambda x: _znc_core.CClient_IsValidIdentifier
    if _newclass:
        IsValidIdentifier = staticmethod(_znc_core.CClient_IsValidIdentifier)

    def UserCommand(self, sLine: 'CString &') -> "void":
        return _znc_core.CClient_UserCommand(self, sLine)

    def UserPortCommand(self, sLine: 'CString &') -> "void":
        return _znc_core.CClient_UserPortCommand(self, sLine)

    def StatusCTCP(self, sCommand: 'CString const &') -> "void":
        return _znc_core.CClient_StatusCTCP(self, sCommand)

    def BouncedOff(self) -> "void":
        return _znc_core.CClient_BouncedOff(self)

    def IsAttached(self) -> "bool":
        return _znc_core.CClient_IsAttached(self)

    def IsPlaybackActive(self) -> "bool":
        return _znc_core.CClient_IsPlaybackActive(self)

    def SetPlaybackActive(self, bActive: 'bool') -> "void":
        return _znc_core.CClient_SetPlaybackActive(self, bActive)

    def PutIRC(self, sLine: 'CString const &') -> "void":
        return _znc_core.CClient_PutIRC(self, sLine)

    def PutClient(self, sLine: 'CString const &') -> "void":
        return _znc_core.CClient_PutClient(self, sLine)

    def PutStatus(self, *args) -> "void":
        return _znc_core.CClient_PutStatus(self, *args)

    def PutStatusNotice(self, sLine: 'CString const &') -> "void":
        return _znc_core.CClient_PutStatusNotice(self, sLine)

    def PutModule(self, sModule: 'CString const &', sLine: 'CString const &') -> "void":
        return _znc_core.CClient_PutModule(self, sModule, sLine)

    def PutModNotice(self, sModule: 'CString const &', sLine: 'CString const &') -> "void":
        return _znc_core.CClient_PutModNotice(self, sModule, sLine)

    def IsCapEnabled(self, sCap: 'CString const &') -> "bool":
        return _znc_core.CClient_IsCapEnabled(self, sCap)

    def ReadLine(self, sData: 'CString const &') -> "void":
        return _znc_core.CClient_ReadLine(self, sData)

    def SendMotd(self) -> "bool":
        return _znc_core.CClient_SendMotd(self)

    def HelpUser(self, *args) -> "void":
        return _znc_core.CClient_HelpUser(self, *args)

    def AuthUser(self) -> "void":
        return _znc_core.CClient_AuthUser(self)

    def Connected(self) -> "void":
        return _znc_core.CClient_Connected(self)

    def Timeout(self) -> "void":
        return _znc_core.CClient_Timeout(self)

    def Disconnected(self) -> "void":
        return _znc_core.CClient_Disconnected(self)

    def ConnectionRefused(self) -> "void":
        return _znc_core.CClient_ConnectionRefused(self)

    def ReachedMaxBuffer(self) -> "void":
        return _znc_core.CClient_ReachedMaxBuffer(self)

    def SetNick(self, s: 'CString const &') -> "void":
        return _znc_core.CClient_SetNick(self, s)

    def SetAway(self, bAway: 'bool') -> "void":
        return _znc_core.CClient_SetAway(self, bAway)

    def GetUser(self) -> "CUser *":
        return _znc_core.CClient_GetUser(self)

    def SetNetwork(self, pNetwork: 'CIRCNetwork', bDisconnect: 'bool'=True, bReconnect: 'bool'=True) -> "void":
        return _znc_core.CClient_SetNetwork(self, pNetwork, bDisconnect, bReconnect)

    def GetNetwork(self) -> "CIRCNetwork *":
        return _znc_core.CClient_GetNetwork(self)

    def GetClients(self) -> "std::vector< CClient *,std::allocator< CClient * > > const &":
        return _znc_core.CClient_GetClients(self)

    def GetIRCSock(self, *args) -> "CIRCSock *":
        return _znc_core.CClient_GetIRCSock(self, *args)

    def GetFullName(self) -> "CString":
        return _znc_core.CClient_GetFullName(self)
CClient_swigregister = _znc_core.CClient_swigregister
CClient_swigregister(CClient)

def CClient_IsValidIdentifier(sIdentifier: 'CString const &') -> "bool":
    return _znc_core.CClient_IsValidIdentifier(sIdentifier)
CClient_IsValidIdentifier = _znc_core.CClient_IsValidIdentifier

class CIRCSock(CIRCSocket):
    __swig_setmethods__ = {}
    for _s in [CIRCSocket]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CIRCSock, name, value)
    __swig_getmethods__ = {}
    for _s in [CIRCSocket]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CIRCSock, name)
    __repr__ = _swig_repr

    def __init__(self, pNetwork: 'CIRCNetwork'):
        this = _znc_core.new_CIRCSock(pNetwork)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CIRCSock
    __del__ = lambda self: None
    ListArg = _znc_core.CIRCSock_ListArg
    HasArg = _znc_core.CIRCSock_HasArg
    ArgWhenSet = _znc_core.CIRCSock_ArgWhenSet
    NoArg = _znc_core.CIRCSock_NoArg

    def OnCTCPReply(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CIRCSock_OnCTCPReply(self, Nick, sMessage)

    def OnPrivCTCP(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CIRCSock_OnPrivCTCP(self, Nick, sMessage)

    def OnChanCTCP(self, Nick: 'CNick', sChan: 'CString const &', sMessage: 'CString &') -> "bool":
        return _znc_core.CIRCSock_OnChanCTCP(self, Nick, sChan, sMessage)

    def OnGeneralCTCP(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CIRCSock_OnGeneralCTCP(self, Nick, sMessage)

    def OnPrivMsg(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CIRCSock_OnPrivMsg(self, Nick, sMessage)

    def OnChanMsg(self, Nick: 'CNick', sChan: 'CString const &', sMessage: 'CString &') -> "bool":
        return _znc_core.CIRCSock_OnChanMsg(self, Nick, sChan, sMessage)

    def OnPrivNotice(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CIRCSock_OnPrivNotice(self, Nick, sMessage)

    def OnChanNotice(self, Nick: 'CNick', sChan: 'CString const &', sMessage: 'CString &') -> "bool":
        return _znc_core.CIRCSock_OnChanNotice(self, Nick, sChan, sMessage)

    def OnServerCapAvailable(self, sCap: 'CString const &') -> "bool":
        return _znc_core.CIRCSock_OnServerCapAvailable(self, sCap)

    def ReadLine(self, sData: 'CString const &') -> "void":
        return _znc_core.CIRCSock_ReadLine(self, sData)

    def Connected(self) -> "void":
        return _znc_core.CIRCSock_Connected(self)

    def Disconnected(self) -> "void":
        return _znc_core.CIRCSock_Disconnected(self)

    def ConnectionRefused(self) -> "void":
        return _znc_core.CIRCSock_ConnectionRefused(self)

    def SockError(self, iErrno: 'int', sDescription: 'CString const &') -> "void":
        return _znc_core.CIRCSock_SockError(self, iErrno, sDescription)

    def Timeout(self) -> "void":
        return _znc_core.CIRCSock_Timeout(self)

    def ReachedMaxBuffer(self) -> "void":
        return _znc_core.CIRCSock_ReachedMaxBuffer(self)

    def PutIRC(self, sLine: 'CString const &') -> "void":
        return _znc_core.CIRCSock_PutIRC(self, sLine)

    def PutIRCQuick(self, sLine: 'CString const &') -> "void":
        return _znc_core.CIRCSock_PutIRCQuick(self, sLine)

    def ResetChans(self) -> "void":
        return _znc_core.CIRCSock_ResetChans(self)

    def Quit(self, *args) -> "void":
        return _znc_core.CIRCSock_Quit(self, *args)

    def PauseCap(self) -> "void":
        return _znc_core.CIRCSock_PauseCap(self)

    def ResumeCap(self) -> "void":
        return _znc_core.CIRCSock_ResumeCap(self)

    def SetPass(self, s: 'CString const &') -> "void":
        return _znc_core.CIRCSock_SetPass(self, s)

    def GetMaxNickLen(self) -> "unsigned int":
        return _znc_core.CIRCSock_GetMaxNickLen(self)

    def GetModeType(self, uMode: 'unsigned char') -> "CIRCSock::EChanModeArgs":
        return _znc_core.CIRCSock_GetModeType(self, uMode)

    def GetPermFromMode(self, uMode: 'unsigned char') -> "unsigned char":
        return _znc_core.CIRCSock_GetPermFromMode(self, uMode)

    def GetChanModes(self) -> "std::map< unsigned char,CIRCSock::EChanModeArgs,std::less< unsigned char >,std::allocator< std::pair< unsigned char const,CIRCSock::EChanModeArgs > > > const &":
        return _znc_core.CIRCSock_GetChanModes(self)

    def IsPermChar(self, c: 'char const') -> "bool":
        return _znc_core.CIRCSock_IsPermChar(self, c)

    def IsPermMode(self, c: 'char const') -> "bool":
        return _znc_core.CIRCSock_IsPermMode(self, c)

    def GetPerms(self) -> "CString const &":
        return _znc_core.CIRCSock_GetPerms(self)

    def GetPermModes(self) -> "CString const &":
        return _znc_core.CIRCSock_GetPermModes(self)

    def GetNickMask(self) -> "CString":
        return _znc_core.CIRCSock_GetNickMask(self)

    def GetNick(self) -> "CString const &":
        return _znc_core.CIRCSock_GetNick(self)

    def GetPass(self) -> "CString const &":
        return _znc_core.CIRCSock_GetPass(self)

    def GetNetwork(self) -> "CIRCNetwork *":
        return _znc_core.CIRCSock_GetNetwork(self)

    def HasNamesx(self) -> "bool":
        return _znc_core.CIRCSock_HasNamesx(self)

    def HasUHNames(self) -> "bool":
        return _znc_core.CIRCSock_HasUHNames(self)

    def GetUserModes(self) -> "std::set< unsigned char,std::less< unsigned char >,std::allocator< unsigned char > > const &":
        return _znc_core.CIRCSock_GetUserModes(self)

    def IsAuthed(self) -> "bool":
        return _znc_core.CIRCSock_IsAuthed(self)

    def IsCapAccepted(self, sCap: 'CString const &') -> "bool":
        return _znc_core.CIRCSock_IsCapAccepted(self, sCap)

    def GetISupport(self, *args) -> "CString":
        return _znc_core.CIRCSock_GetISupport(self, *args)

    def ForwardRaw353(self, *args) -> "void":
        return _znc_core.CIRCSock_ForwardRaw353(self, *args)
    __swig_getmethods__["IsFloodProtected"] = lambda x: _znc_core.CIRCSock_IsFloodProtected
    if _newclass:
        IsFloodProtected = staticmethod(_znc_core.CIRCSock_IsFloodProtected)
CIRCSock_swigregister = _znc_core.CIRCSock_swigregister
CIRCSock_swigregister(CIRCSock)

def CIRCSock_IsFloodProtected(fRate: 'double') -> "bool":
    return _znc_core.CIRCSock_IsFloodProtected(fRate)
CIRCSock_IsFloodProtected = _znc_core.CIRCSock_IsFloodProtected

class CListener(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CListener, name)
    __repr__ = _swig_repr
    ACCEPT_IRC = _znc_core.CListener_ACCEPT_IRC
    ACCEPT_HTTP = _znc_core.CListener_ACCEPT_HTTP
    ACCEPT_ALL = _znc_core.CListener_ACCEPT_ALL

    def __init__(self, uPort: 'unsigned short', sBindHost: 'CString const &', sURIPrefix: 'CString const &', bSSL: 'bool', eAddr: 'EAddrType', eAccept: 'CListener::EAcceptType'):
        this = _znc_core.new_CListener(uPort, sBindHost, sURIPrefix, bSSL, eAddr, eAccept)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CListener
    __del__ = lambda self: None

    def IsSSL(self) -> "bool":
        return _znc_core.CListener_IsSSL(self)

    def GetAddrType(self) -> "EAddrType":
        return _znc_core.CListener_GetAddrType(self)

    def GetPort(self) -> "unsigned short":
        return _znc_core.CListener_GetPort(self)

    def GetBindHost(self) -> "CString const &":
        return _znc_core.CListener_GetBindHost(self)

    def GetRealListener(self) -> "CRealListener *":
        return _znc_core.CListener_GetRealListener(self)

    def GetURIPrefix(self) -> "CString const &":
        return _znc_core.CListener_GetURIPrefix(self)

    def GetAcceptType(self) -> "CListener::EAcceptType":
        return _znc_core.CListener_GetAcceptType(self)

    def SetAcceptType(self, eType: 'CListener::EAcceptType') -> "void":
        return _znc_core.CListener_SetAcceptType(self, eType)

    def Listen(self) -> "bool":
        return _znc_core.CListener_Listen(self)

    def ResetRealListener(self) -> "void":
        return _znc_core.CListener_ResetRealListener(self)
CListener_swigregister = _znc_core.CListener_swigregister
CListener_swigregister(CListener)

class CRealListener(CZNCSock):
    __swig_setmethods__ = {}
    for _s in [CZNCSock]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CRealListener, name, value)
    __swig_getmethods__ = {}
    for _s in [CZNCSock]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CRealListener, name)
    __repr__ = _swig_repr

    def __init__(self, listener: 'CListener'):
        this = _znc_core.new_CRealListener(listener)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CRealListener
    __del__ = lambda self: None

    def ConnectionFrom(self, sHost: 'CString const &', uPort: 'unsigned short') -> "bool":
        return _znc_core.CRealListener_ConnectionFrom(self, sHost, uPort)

    def GetSockObj(self, sHost: 'CString const &', uPort: 'unsigned short') -> "Csock *":
        return _znc_core.CRealListener_GetSockObj(self, sHost, uPort)

    def SockError(self, iErrno: 'int', sDescription: 'CString const &') -> "void":
        return _znc_core.CRealListener_SockError(self, iErrno, sDescription)
CRealListener_swigregister = _znc_core.CRealListener_swigregister
CRealListener_swigregister(CRealListener)

class CIncomingConnection(CZNCSock):
    __swig_setmethods__ = {}
    for _s in [CZNCSock]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CIncomingConnection, name, value)
    __swig_getmethods__ = {}
    for _s in [CZNCSock]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CIncomingConnection, name)
    __repr__ = _swig_repr

    def __init__(self, sHostname: 'CString const &', uPort: 'unsigned short', eAcceptType: 'CListener::EAcceptType', sURIPrefix: 'CString const &'):
        this = _znc_core.new_CIncomingConnection(sHostname, uPort, eAcceptType, sURIPrefix)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CIncomingConnection
    __del__ = lambda self: None

    def ReadLine(self, sData: 'CString const &') -> "void":
        return _znc_core.CIncomingConnection_ReadLine(self, sData)

    def ReachedMaxBuffer(self) -> "void":
        return _znc_core.CIncomingConnection_ReachedMaxBuffer(self)
CIncomingConnection_swigregister = _znc_core.CIncomingConnection_swigregister
CIncomingConnection_swigregister(CIncomingConnection)

class CHTTPSock(CSocket):
    __swig_setmethods__ = {}
    for _s in [CSocket]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHTTPSock, name, value)
    __swig_getmethods__ = {}
    for _s in [CSocket]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHTTPSock, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _znc_core.delete_CHTTPSock
    __del__ = lambda self: None

    def ReadData(self, data: 'char const *', len: 'size_t') -> "void":
        return _znc_core.CHTTPSock_ReadData(self, data, len)

    def ReadLine(self, sData: 'CString const &') -> "void":
        return _znc_core.CHTTPSock_ReadLine(self, sData)

    def Connected(self) -> "void":
        return _znc_core.CHTTPSock_Connected(self)

    def GetSockObj(self, sHost: 'CString const &', uPort: 'unsigned short') -> "Csock *":
        return _znc_core.CHTTPSock_GetSockObj(self, sHost, uPort)

    def ForceLogin(self) -> "bool":
        return _znc_core.CHTTPSock_ForceLogin(self)

    def OnLogin(self, sUser: 'CString const &', sPass: 'CString const &', bBasic: 'bool') -> "bool":
        return _znc_core.CHTTPSock_OnLogin(self, sUser, sPass, bBasic)

    def OnPageRequest(self, sURI: 'CString const &') -> "void":
        return _znc_core.CHTTPSock_OnPageRequest(self, sURI)

    def PrintFile(self, *args) -> "bool":
        return _znc_core.CHTTPSock_PrintFile(self, *args)

    def CheckPost(self) -> "void":
        return _znc_core.CHTTPSock_CheckPost(self)

    def SentHeader(self) -> "bool":
        return _znc_core.CHTTPSock_SentHeader(self)

    def PrintHeader(self, *args) -> "bool":
        return _znc_core.CHTTPSock_PrintHeader(self, *args)

    def AddHeader(self, sName: 'CString const &', sValue: 'CString const &') -> "void":
        return _znc_core.CHTTPSock_AddHeader(self, sName, sValue)

    def SetContentType(self, sContentType: 'CString const &') -> "void":
        return _znc_core.CHTTPSock_SetContentType(self, sContentType)

    def PrintNotFound(self) -> "bool":
        return _znc_core.CHTTPSock_PrintNotFound(self)

    def Redirect(self, sURL: 'CString const &') -> "bool":
        return _znc_core.CHTTPSock_Redirect(self, sURL)

    def PrintErrorPage(self, uStatusId: 'unsigned int', sStatusMsg: 'CString const &', sMessage: 'CString const &') -> "bool":
        return _znc_core.CHTTPSock_PrintErrorPage(self, uStatusId, sStatusMsg, sMessage)
    __swig_getmethods__["ParseParams"] = lambda x: _znc_core.CHTTPSock_ParseParams
    if _newclass:
        ParseParams = staticmethod(_znc_core.CHTTPSock_ParseParams)

    def ParseURI(self) -> "void":
        return _znc_core.CHTTPSock_ParseURI(self)

    def GetPage(self) -> "void":
        return _znc_core.CHTTPSock_GetPage(self)
    __swig_getmethods__["GetDate"] = lambda x: _znc_core.CHTTPSock_GetDate
    if _newclass:
        GetDate = staticmethod(_znc_core.CHTTPSock_GetDate)

    def GetRemoteIP(self) -> "CString":
        return _znc_core.CHTTPSock_GetRemoteIP(self)

    def GetRequestCookie(self, sKey: 'CString const &') -> "CString":
        return _znc_core.CHTTPSock_GetRequestCookie(self, sKey)

    def SendCookie(self, sKey: 'CString const &', sValue: 'CString const &') -> "bool":
        return _znc_core.CHTTPSock_SendCookie(self, sKey, sValue)

    def SetDocRoot(self, s: 'CString const &') -> "void":
        return _znc_core.CHTTPSock_SetDocRoot(self, s)

    def SetLoggedIn(self, b: 'bool') -> "void":
        return _znc_core.CHTTPSock_SetLoggedIn(self, b)

    def GetPath(self) -> "CString":
        return _znc_core.CHTTPSock_GetPath(self)

    def IsLoggedIn(self) -> "bool":
        return _znc_core.CHTTPSock_IsLoggedIn(self)

    def GetDocRoot(self) -> "CString const &":
        return _znc_core.CHTTPSock_GetDocRoot(self)

    def GetUser(self) -> "CString const &":
        return _znc_core.CHTTPSock_GetUser(self)

    def GetPass(self) -> "CString const &":
        return _znc_core.CHTTPSock_GetPass(self)

    def GetParamString(self) -> "CString const &":
        return _znc_core.CHTTPSock_GetParamString(self)

    def GetContentType(self) -> "CString const &":
        return _znc_core.CHTTPSock_GetContentType(self)

    def GetURIPrefix(self) -> "CString const &":
        return _znc_core.CHTTPSock_GetURIPrefix(self)

    def IsPost(self) -> "bool":
        return _znc_core.CHTTPSock_IsPost(self)

    def GetParam(self, *args) -> "CString":
        return _znc_core.CHTTPSock_GetParam(self, *args)

    def GetRawParam(self, sName: 'CString const &', bPost: 'bool'=True) -> "CString":
        return _znc_core.CHTTPSock_GetRawParam(self, sName, bPost)

    def HasParam(self, sName: 'CString const &', bPost: 'bool'=True) -> "bool":
        return _znc_core.CHTTPSock_HasParam(self, sName, bPost)

    def GetParams(self, bPost: 'bool'=True) -> "std::map< CString,VCString,std::less< CString >,std::allocator< std::pair< CString const,VCString > > > const &":
        return _znc_core.CHTTPSock_GetParams(self, bPost)

    def GetParamValues(self, *args) -> "size_t":
        return _znc_core.CHTTPSock_GetParamValues(self, *args)
CHTTPSock_swigregister = _znc_core.CHTTPSock_swigregister
CHTTPSock_swigregister(CHTTPSock)

def CHTTPSock_ParseParams(sParams: 'CString const &', msvsParams: 'PyMStringVString') -> "void":
    return _znc_core.CHTTPSock_ParseParams(sParams, msvsParams)
CHTTPSock_ParseParams = _znc_core.CHTTPSock_ParseParams

def CHTTPSock_GetDate(tm: 'time_t'=0) -> "CString":
    return _znc_core.CHTTPSock_GetDate(tm)
CHTTPSock_GetDate = _znc_core.CHTTPSock_GetDate

class CTemplateTagHandler(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CTemplateTagHandler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CTemplateTagHandler, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CTemplateTagHandler()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CTemplateTagHandler
    __del__ = lambda self: None

    def HandleVar(self, Tmpl: 'CTemplate', sName: 'CString const &', sArgs: 'CString const &', sOutput: 'CString &') -> "bool":
        return _znc_core.CTemplateTagHandler_HandleVar(self, Tmpl, sName, sArgs, sOutput)

    def HandleTag(self, Tmpl: 'CTemplate', sName: 'CString const &', sArgs: 'CString const &', sOutput: 'CString &') -> "bool":
        return _znc_core.CTemplateTagHandler_HandleTag(self, Tmpl, sName, sArgs, sOutput)

    def HandleIf(self, Tmpl: 'CTemplate', sName: 'CString const &', sArgs: 'CString const &', sOutput: 'CString &') -> "bool":
        return _znc_core.CTemplateTagHandler_HandleIf(self, Tmpl, sName, sArgs, sOutput)

    def HandleValue(self, Tmpl: 'CTemplate', sValue: 'CString &', msOptions: 'MCString') -> "bool":
        return _znc_core.CTemplateTagHandler_HandleValue(self, Tmpl, sValue, msOptions)
CTemplateTagHandler_swigregister = _znc_core.CTemplateTagHandler_swigregister
CTemplateTagHandler_swigregister(CTemplateTagHandler)

class CTemplateOptions(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CTemplateOptions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CTemplateOptions, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CTemplateOptions()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CTemplateOptions
    __del__ = lambda self: None

    def Parse(self, sLine: 'CString const &') -> "void":
        return _znc_core.CTemplateOptions_Parse(self, sLine)

    def GetEscapeFrom(self) -> "CString::EEscape":
        return _znc_core.CTemplateOptions_GetEscapeFrom(self)

    def GetEscapeTo(self) -> "CString::EEscape":
        return _znc_core.CTemplateOptions_GetEscapeTo(self)
CTemplateOptions_swigregister = _znc_core.CTemplateOptions_swigregister
CTemplateOptions_swigregister(CTemplateOptions)

class CTemplateLoopContext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CTemplateLoopContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CTemplateLoopContext, name)
    __repr__ = _swig_repr

    def __init__(self, uFilePos: 'unsigned long', sLoopName: 'CString const &', bReverse: 'bool', pRows: 'std::vector< CTemplate *,std::allocator< CTemplate * > > *'):
        this = _znc_core.new_CTemplateLoopContext(uFilePos, sLoopName, bReverse, pRows)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CTemplateLoopContext
    __del__ = lambda self: None

    def SetHasData(self, b: 'bool'=True) -> "void":
        return _znc_core.CTemplateLoopContext_SetHasData(self, b)

    def SetName(self, s: 'CString const &') -> "void":
        return _znc_core.CTemplateLoopContext_SetName(self, s)

    def SetRowIndex(self, u: 'unsigned int') -> "void":
        return _znc_core.CTemplateLoopContext_SetRowIndex(self, u)

    def IncRowIndex(self) -> "unsigned int":
        return _znc_core.CTemplateLoopContext_IncRowIndex(self)

    def DecRowIndex(self) -> "unsigned int":
        return _znc_core.CTemplateLoopContext_DecRowIndex(self)

    def SetFilePosition(self, u: 'unsigned int') -> "void":
        return _znc_core.CTemplateLoopContext_SetFilePosition(self, u)

    def HasData(self) -> "bool":
        return _znc_core.CTemplateLoopContext_HasData(self)

    def GetName(self) -> "CString const &":
        return _znc_core.CTemplateLoopContext_GetName(self)

    def GetFilePosition(self) -> "unsigned long":
        return _znc_core.CTemplateLoopContext_GetFilePosition(self)

    def GetRowIndex(self) -> "unsigned int":
        return _znc_core.CTemplateLoopContext_GetRowIndex(self)

    def GetRowCount(self) -> "size_t":
        return _znc_core.CTemplateLoopContext_GetRowCount(self)

    def GetRows(self) -> "std::vector< CTemplate *,std::allocator< CTemplate * > > *":
        return _znc_core.CTemplateLoopContext_GetRows(self)

    def GetNextRow(self) -> "CTemplate *":
        return _znc_core.CTemplateLoopContext_GetNextRow(self)

    def GetCurRow(self) -> "CTemplate *":
        return _znc_core.CTemplateLoopContext_GetCurRow(self)

    def GetRow(self, uIndex: 'unsigned int') -> "CTemplate *":
        return _znc_core.CTemplateLoopContext_GetRow(self, uIndex)

    def GetValue(self, sName: 'CString const &', bFromIf: 'bool'=False) -> "CString":
        return _znc_core.CTemplateLoopContext_GetValue(self, sName, bFromIf)
CTemplateLoopContext_swigregister = _znc_core.CTemplateLoopContext_swigregister
CTemplateLoopContext_swigregister(CTemplateLoopContext)

class CTemplate(MCString):
    __swig_setmethods__ = {}
    for _s in [MCString]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CTemplate, name, value)
    __swig_getmethods__ = {}
    for _s in [MCString]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CTemplate, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CTemplate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CTemplate
    __del__ = lambda self: None

    def AddTagHandler(self, spTagHandler: 'std::shared_ptr< CTemplateTagHandler >') -> "void":
        return _znc_core.CTemplate_AddTagHandler(self, spTagHandler)

    def GetTagHandlers(self) -> "std::vector< std::shared_ptr< CTemplateTagHandler >,std::allocator< std::shared_ptr< CTemplateTagHandler > > > &":
        return _znc_core.CTemplate_GetTagHandlers(self)

    def ResolveLiteral(self, sString: 'CString const &') -> "CString":
        return _znc_core.CTemplate_ResolveLiteral(self, sString)

    def Init(self) -> "void":
        return _znc_core.CTemplate_Init(self)

    def GetParent(self, bRoot: 'bool') -> "CTemplate *":
        return _znc_core.CTemplate_GetParent(self, bRoot)

    def ExpandFile(self, sFilename: 'CString const &', bFromInc: 'bool'=False) -> "CString":
        return _znc_core.CTemplate_ExpandFile(self, sFilename, bFromInc)

    def SetFile(self, sFileName: 'CString const &') -> "bool":
        return _znc_core.CTemplate_SetFile(self, sFileName)

    def SetPath(self, sPath: 'CString const &') -> "void":
        return _znc_core.CTemplate_SetPath(self, sPath)

    def MakePath(self, sPath: 'CString const &') -> "CString":
        return _znc_core.CTemplate_MakePath(self, sPath)

    def PrependPath(self, sPath: 'CString const &', bIncludesOnly: 'bool'=False) -> "void":
        return _znc_core.CTemplate_PrependPath(self, sPath, bIncludesOnly)

    def AppendPath(self, sPath: 'CString const &', bIncludesOnly: 'bool'=False) -> "void":
        return _znc_core.CTemplate_AppendPath(self, sPath, bIncludesOnly)

    def RemovePath(self, sPath: 'CString const &') -> "void":
        return _znc_core.CTemplate_RemovePath(self, sPath)

    def ClearPaths(self) -> "void":
        return _znc_core.CTemplate_ClearPaths(self)

    def PrintString(self, sRet: 'CString &') -> "bool":
        return _znc_core.CTemplate_PrintString(self, sRet)

    def Print(self, *args) -> "bool":
        return _znc_core.CTemplate_Print(self, *args)

    def ValidIf(self, sArgs: 'CString const &') -> "bool":
        return _znc_core.CTemplate_ValidIf(self, sArgs)

    def ValidExpr(self, sExpr: 'CString const &') -> "bool":
        return _znc_core.CTemplate_ValidExpr(self, sExpr)

    def IsTrue(self, sName: 'CString const &') -> "bool":
        return _znc_core.CTemplate_IsTrue(self, sName)

    def HasLoop(self, sName: 'CString const &') -> "bool":
        return _znc_core.CTemplate_HasLoop(self, sName)

    def GetValue(self, sName: 'CString const &', bFromIf: 'bool'=False) -> "CString":
        return _znc_core.CTemplate_GetValue(self, sName, bFromIf)

    def AddRow(self, sName: 'CString const &') -> "CTemplate &":
        return _znc_core.CTemplate_AddRow(self, sName)

    def GetRow(self, sName: 'CString const &', uIndex: 'unsigned int') -> "CTemplate *":
        return _znc_core.CTemplate_GetRow(self, sName, uIndex)

    def GetLoop(self, sName: 'CString const &') -> "std::vector< CTemplate *,std::allocator< CTemplate * > > *":
        return _znc_core.CTemplate_GetLoop(self, sName)

    def DelCurLoopContext(self) -> "void":
        return _znc_core.CTemplate_DelCurLoopContext(self)

    def GetCurLoopContext(self) -> "CTemplateLoopContext *":
        return _znc_core.CTemplate_GetCurLoopContext(self)

    def GetCurTemplate(self) -> "CTemplate *":
        return _znc_core.CTemplate_GetCurTemplate(self)

    def GetFileName(self) -> "CString const &":
        return _znc_core.CTemplate_GetFileName(self)

    def set(self, key: 'CString const &', value: 'CString const &') -> "void":
        return _znc_core.CTemplate_set(self, key, value)
CTemplate_swigregister = _znc_core.CTemplate_swigregister
CTemplate_swigregister(CTemplate)

class CZNCTagHandler(CTemplateTagHandler):
    __swig_setmethods__ = {}
    for _s in [CTemplateTagHandler]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CZNCTagHandler, name, value)
    __swig_getmethods__ = {}
    for _s in [CTemplateTagHandler]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CZNCTagHandler, name)
    __repr__ = _swig_repr

    def __init__(self, pWebSock: 'CWebSock'):
        this = _znc_core.new_CZNCTagHandler(pWebSock)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CZNCTagHandler
    __del__ = lambda self: None

    def HandleTag(self, Tmpl: 'CTemplate', sName: 'CString const &', sArgs: 'CString const &', sOutput: 'CString &') -> "bool":
        return _znc_core.CZNCTagHandler_HandleTag(self, Tmpl, sName, sArgs, sOutput)
CZNCTagHandler_swigregister = _znc_core.CZNCTagHandler_swigregister
CZNCTagHandler_swigregister(CZNCTagHandler)

class CWebSession(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CWebSession, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CWebSession, name)
    __repr__ = _swig_repr

    def __init__(self, sId: 'CString const &', sIP: 'CString const &'):
        this = _znc_core.new_CWebSession(sId, sIP)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CWebSession
    __del__ = lambda self: None

    def GetId(self) -> "CString const &":
        return _znc_core.CWebSession_GetId(self)

    def GetIP(self) -> "CString const &":
        return _znc_core.CWebSession_GetIP(self)

    def GetUser(self) -> "CUser *":
        return _znc_core.CWebSession_GetUser(self)

    def GetLastActive(self) -> "time_t":
        return _znc_core.CWebSession_GetLastActive(self)

    def IsLoggedIn(self) -> "bool":
        return _znc_core.CWebSession_IsLoggedIn(self)

    def IsAdmin(self) -> "bool":
        return _znc_core.CWebSession_IsAdmin(self)

    def UpdateLastActive(self) -> "void":
        return _znc_core.CWebSession_UpdateLastActive(self)

    def SetUser(self, p: 'CUser') -> "CUser *":
        return _znc_core.CWebSession_SetUser(self, p)

    def ClearMessageLoops(self) -> "void":
        return _znc_core.CWebSession_ClearMessageLoops(self)

    def FillMessageLoops(self, Tmpl: 'CTemplate') -> "void":
        return _znc_core.CWebSession_FillMessageLoops(self, Tmpl)

    def AddError(self, sMessage: 'CString const &') -> "size_t":
        return _znc_core.CWebSession_AddError(self, sMessage)

    def AddSuccess(self, sMessage: 'CString const &') -> "size_t":
        return _znc_core.CWebSession_AddSuccess(self, sMessage)
CWebSession_swigregister = _znc_core.CWebSession_swigregister
CWebSession_swigregister(CWebSession)

class CWebSubPage(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CWebSubPage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CWebSubPage, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CWebSubPage(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CWebSubPage
    __del__ = lambda self: None
    F_ADMIN = _znc_core.CWebSubPage_F_ADMIN

    def SetName(self, s: 'CString const &') -> "void":
        return _znc_core.CWebSubPage_SetName(self, s)

    def SetTitle(self, s: 'CString const &') -> "void":
        return _znc_core.CWebSubPage_SetTitle(self, s)

    def AddParam(self, sName: 'CString const &', sValue: 'CString const &') -> "void":
        return _znc_core.CWebSubPage_AddParam(self, sName, sValue)

    def RequiresAdmin(self) -> "bool":
        return _znc_core.CWebSubPage_RequiresAdmin(self)

    def GetName(self) -> "CString const &":
        return _znc_core.CWebSubPage_GetName(self)

    def GetTitle(self) -> "CString const &":
        return _znc_core.CWebSubPage_GetTitle(self)

    def GetParams(self) -> "VPair const &":
        return _znc_core.CWebSubPage_GetParams(self)
CWebSubPage_swigregister = _znc_core.CWebSubPage_swigregister
CWebSubPage_swigregister(CWebSubPage)

class CWebSessionMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CWebSessionMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CWebSessionMap, name)
    __repr__ = _swig_repr

    def __init__(self, uTTL: 'unsigned int'=5000):
        this = _znc_core.new_CWebSessionMap(uTTL)
        try:
            self.this.append(this)
        except:
            self.this = this

    def FinishUserSessions(self, User: 'CUser') -> "void":
        return _znc_core.CWebSessionMap_FinishUserSessions(self, User)
    __swig_destroy__ = _znc_core.delete_CWebSessionMap
    __del__ = lambda self: None
CWebSessionMap_swigregister = _znc_core.CWebSessionMap_swigregister
CWebSessionMap_swigregister(CWebSessionMap)

class CWebSock(CHTTPSock):
    __swig_setmethods__ = {}
    for _s in [CHTTPSock]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CWebSock, name, value)
    __swig_getmethods__ = {}
    for _s in [CHTTPSock]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CWebSock, name)
    __repr__ = _swig_repr
    PAGE_NOTFOUND = _znc_core.CWebSock_PAGE_NOTFOUND
    PAGE_PRINT = _znc_core.CWebSock_PAGE_PRINT
    PAGE_DEFERRED = _znc_core.CWebSock_PAGE_DEFERRED
    PAGE_DONE = _znc_core.CWebSock_PAGE_DONE

    def __init__(self, sURIPrefix: 'CString const &'):
        this = _znc_core.new_CWebSock(sURIPrefix)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CWebSock
    __del__ = lambda self: None

    def ForceLogin(self) -> "bool":
        return _znc_core.CWebSock_ForceLogin(self)

    def OnLogin(self, sUser: 'CString const &', sPass: 'CString const &', bBasic: 'bool') -> "bool":
        return _znc_core.CWebSock_OnLogin(self, sUser, sPass, bBasic)

    def OnPageRequest(self, sURI: 'CString const &') -> "void":
        return _znc_core.CWebSock_OnPageRequest(self, sURI)

    def PrintTemplate(self, sPageName: 'CString const &', sPageRet: 'CString &', pModule: 'CModule'=None) -> "CWebSock::EPageReqResult":
        return _znc_core.CWebSock_PrintTemplate(self, sPageName, sPageRet, pModule)

    def PrintStaticFile(self, sPath: 'CString const &', sPageRet: 'CString &', pModule: 'CModule'=None) -> "CWebSock::EPageReqResult":
        return _znc_core.CWebSock_PrintStaticFile(self, sPath, sPageRet, pModule)

    def FindTmpl(self, pModule: 'CModule', sName: 'CString const &') -> "CString":
        return _znc_core.CWebSock_FindTmpl(self, pModule, sName)

    def GetSession(self) -> "std::shared_ptr< CWebSession >":
        return _znc_core.CWebSock_GetSession(self)

    def GetSockObj(self, sHost: 'CString const &', uPort: 'unsigned short') -> "Csock *":
        return _znc_core.CWebSock_GetSockObj(self, sHost, uPort)
    __swig_getmethods__["GetSkinPath"] = lambda x: _znc_core.CWebSock_GetSkinPath
    if _newclass:
        GetSkinPath = staticmethod(_znc_core.CWebSock_GetSkinPath)

    def GetAvailSkins(self, vRet: 'VCString') -> "void":
        return _znc_core.CWebSock_GetAvailSkins(self, vRet)

    def GetSkinName(self) -> "CString":
        return _znc_core.CWebSock_GetSkinName(self)

    def GetRequestCookie(self, sKey: 'CString const &') -> "CString":
        return _znc_core.CWebSock_GetRequestCookie(self, sKey)

    def SendCookie(self, sKey: 'CString const &', sValue: 'CString const &') -> "bool":
        return _znc_core.CWebSock_SendCookie(self, sKey, sValue)
    __swig_getmethods__["FinishUserSessions"] = lambda x: _znc_core.CWebSock_FinishUserSessions
    if _newclass:
        FinishUserSessions = staticmethod(_znc_core.CWebSock_FinishUserSessions)
CWebSock_swigregister = _znc_core.CWebSock_swigregister
CWebSock_swigregister(CWebSock)

def CWebSock_GetSkinPath(sSkinName: 'CString const &') -> "CString":
    return _znc_core.CWebSock_GetSkinPath(sSkinName)
CWebSock_GetSkinPath = _znc_core.CWebSock_GetSkinPath

def CWebSock_FinishUserSessions(User: 'CUser') -> "void":
    return _znc_core.CWebSock_FinishUserSessions(User)
CWebSock_FinishUserSessions = _znc_core.CWebSock_FinishUserSessions

class CZNC(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CZNC, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CZNC, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CZNC()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CZNC
    __del__ = lambda self: None
    ECONFIG_NOTHING = _znc_core.CZNC_ECONFIG_NOTHING
    ECONFIG_NEED_REHASH = _znc_core.CZNC_ECONFIG_NEED_REHASH
    ECONFIG_NEED_WRITE = _znc_core.CZNC_ECONFIG_NEED_WRITE
    ECONFIG_NEED_VERBOSE_WRITE = _znc_core.CZNC_ECONFIG_NEED_VERBOSE_WRITE

    def DeleteUsers(self) -> "void":
        return _znc_core.CZNC_DeleteUsers(self)

    def Loop(self) -> "void":
        return _znc_core.CZNC_Loop(self)

    def WritePidFile(self, iPid: 'int') -> "bool":
        return _znc_core.CZNC_WritePidFile(self, iPid)

    def DeletePidFile(self) -> "bool":
        return _znc_core.CZNC_DeletePidFile(self)

    def WaitForChildLock(self) -> "bool":
        return _znc_core.CZNC_WaitForChildLock(self)

    def IsHostAllowed(self, sHostMask: 'CString const &') -> "bool":
        return _znc_core.CZNC_IsHostAllowed(self, sHostMask)

    def AllowConnectionFrom(self, sIP: 'CString const &') -> "bool":
        return _znc_core.CZNC_AllowConnectionFrom(self, sIP)

    def InitDirs(self, sArgvPath: 'CString const &', sDataDir: 'CString const &') -> "void":
        return _znc_core.CZNC_InitDirs(self, sArgvPath, sDataDir)

    def OnBoot(self) -> "bool":
        return _znc_core.CZNC_OnBoot(self)

    def ExpandConfigPath(self, sConfigFile: 'CString const &', bAllowMkDir: 'bool'=True) -> "CString":
        return _znc_core.CZNC_ExpandConfigPath(self, sConfigFile, bAllowMkDir)

    def WriteNewConfig(self, sConfigFile: 'CString const &') -> "bool":
        return _znc_core.CZNC_WriteNewConfig(self, sConfigFile)

    def WriteConfig(self) -> "bool":
        return _znc_core.CZNC_WriteConfig(self)

    def ParseConfig(self, sConfig: 'CString const &', sError: 'CString &') -> "bool":
        return _znc_core.CZNC_ParseConfig(self, sConfig, sError)

    def RehashConfig(self, sError: 'CString &') -> "bool":
        return _znc_core.CZNC_RehashConfig(self, sError)

    def BackupConfigOnce(self, sSuffix: 'CString const &') -> "void":
        return _znc_core.CZNC_BackupConfigOnce(self, sSuffix)
    __swig_getmethods__["GetVersion"] = lambda x: _znc_core.CZNC_GetVersion
    if _newclass:
        GetVersion = staticmethod(_znc_core.CZNC_GetVersion)
    __swig_getmethods__["GetTag"] = lambda x: _znc_core.CZNC_GetTag
    if _newclass:
        GetTag = staticmethod(_znc_core.CZNC_GetTag)
    __swig_getmethods__["GetCompileOptionsString"] = lambda x: _znc_core.CZNC_GetCompileOptionsString
    if _newclass:
        GetCompileOptionsString = staticmethod(_znc_core.CZNC_GetCompileOptionsString)

    def GetUptime(self) -> "CString":
        return _znc_core.CZNC_GetUptime(self)

    def ClearBindHosts(self) -> "void":
        return _znc_core.CZNC_ClearBindHosts(self)

    def AddBindHost(self, sHost: 'CString const &') -> "bool":
        return _znc_core.CZNC_AddBindHost(self, sHost)

    def RemBindHost(self, sHost: 'CString const &') -> "bool":
        return _znc_core.CZNC_RemBindHost(self, sHost)

    def ClearTrustedProxies(self) -> "void":
        return _znc_core.CZNC_ClearTrustedProxies(self)

    def AddTrustedProxy(self, sHost: 'CString const &') -> "bool":
        return _znc_core.CZNC_AddTrustedProxy(self, sHost)

    def RemTrustedProxy(self, sHost: 'CString const &') -> "bool":
        return _znc_core.CZNC_RemTrustedProxy(self, sHost)

    def Broadcast(self, sMessage: 'CString const &', bAdminOnly: 'bool'=False, pSkipUser: 'CUser'=None, pSkipClient: 'CClient'=None) -> "void":
        return _znc_core.CZNC_Broadcast(self, sMessage, bAdminOnly, pSkipUser, pSkipClient)

    def AddBytesRead(self, u: 'unsigned long long') -> "void":
        return _znc_core.CZNC_AddBytesRead(self, u)

    def AddBytesWritten(self, u: 'unsigned long long') -> "void":
        return _znc_core.CZNC_AddBytesWritten(self, u)

    def BytesRead(self) -> "unsigned long long":
        return _znc_core.CZNC_BytesRead(self)

    def BytesWritten(self) -> "unsigned long long":
        return _znc_core.CZNC_BytesWritten(self)

    def GetTrafficStats(self, Users: 'CZNC::TrafficStatsPair &', ZNC: 'CZNC::TrafficStatsPair &', Total: 'CZNC::TrafficStatsPair &') -> "CZNC::TrafficStatsMap":
        return _znc_core.CZNC_GetTrafficStats(self, Users, ZNC, Total)

    def AuthUser(self, AuthClass: 'std::shared_ptr< CAuthBase >') -> "void":
        return _znc_core.CZNC_AuthUser(self, AuthClass)

    def SetConfigState(self, e: 'enum CZNC::ConfigState') -> "void":
        return _znc_core.CZNC_SetConfigState(self, e)

    def SetSkinName(self, s: 'CString const &') -> "void":
        return _znc_core.CZNC_SetSkinName(self, s)

    def SetStatusPrefix(self, s: 'CString const &') -> "void":
        return _znc_core.CZNC_SetStatusPrefix(self, s)

    def SetMaxBufferSize(self, i: 'unsigned int') -> "void":
        return _znc_core.CZNC_SetMaxBufferSize(self, i)

    def SetAnonIPLimit(self, i: 'unsigned int') -> "void":
        return _znc_core.CZNC_SetAnonIPLimit(self, i)

    def SetServerThrottle(self, i: 'unsigned int') -> "void":
        return _znc_core.CZNC_SetServerThrottle(self, i)

    def SetProtectWebSessions(self, b: 'bool') -> "void":
        return _znc_core.CZNC_SetProtectWebSessions(self, b)

    def SetHideVersion(self, b: 'bool') -> "void":
        return _znc_core.CZNC_SetHideVersion(self, b)

    def SetConnectDelay(self, i: 'unsigned int') -> "void":
        return _znc_core.CZNC_SetConnectDelay(self, i)

    def GetConfigState(self) -> "enum CZNC::ConfigState":
        return _znc_core.CZNC_GetConfigState(self)

    def GetManager(self, *args) -> "CSockManager const &":
        return _znc_core.CZNC_GetManager(self, *args)

    def GetModules(self) -> "CModules &":
        return _znc_core.CZNC_GetModules(self)

    def GetSkinName(self) -> "CString":
        return _znc_core.CZNC_GetSkinName(self)

    def GetStatusPrefix(self) -> "CString const &":
        return _znc_core.CZNC_GetStatusPrefix(self)

    def GetCurPath(self) -> "CString const &":
        return _znc_core.CZNC_GetCurPath(self)

    def GetHomePath(self) -> "CString const &":
        return _znc_core.CZNC_GetHomePath(self)

    def GetZNCPath(self) -> "CString const &":
        return _znc_core.CZNC_GetZNCPath(self)

    def GetConfPath(self, bAllowMkDir: 'bool'=True) -> "CString":
        return _znc_core.CZNC_GetConfPath(self, bAllowMkDir)

    def GetUserPath(self) -> "CString":
        return _znc_core.CZNC_GetUserPath(self)

    def GetModPath(self) -> "CString":
        return _znc_core.CZNC_GetModPath(self)

    def GetPemLocation(self) -> "CString":
        return _znc_core.CZNC_GetPemLocation(self)

    def GetConfigFile(self) -> "CString const &":
        return _znc_core.CZNC_GetConfigFile(self)

    def WritePemFile(self) -> "bool":
        return _znc_core.CZNC_WritePemFile(self)

    def GetBindHosts(self) -> "VCString const &":
        return _znc_core.CZNC_GetBindHosts(self)

    def GetTrustedProxies(self) -> "VCString const &":
        return _znc_core.CZNC_GetTrustedProxies(self)

    def GetListeners(self) -> "std::vector< CListener *,std::allocator< CListener * > > const &":
        return _znc_core.CZNC_GetListeners(self)

    def TimeStarted(self) -> "time_t":
        return _znc_core.CZNC_TimeStarted(self)

    def GetMaxBufferSize(self) -> "unsigned int":
        return _znc_core.CZNC_GetMaxBufferSize(self)

    def GetAnonIPLimit(self) -> "unsigned int":
        return _znc_core.CZNC_GetAnonIPLimit(self)

    def GetConnectDelay(self) -> "unsigned int":
        return _znc_core.CZNC_GetConnectDelay(self)

    def GetProtectWebSessions(self) -> "bool":
        return _znc_core.CZNC_GetProtectWebSessions(self)

    def GetHideVersion(self) -> "bool":
        return _znc_core.CZNC_GetHideVersion(self)

    def GetSSLCiphers(self) -> "CString":
        return _znc_core.CZNC_GetSSLCiphers(self)

    def GetDisabledSSLProtocols(self) -> "Csock::EDisableProtocol":
        return _znc_core.CZNC_GetDisabledSSLProtocols(self)
    __swig_getmethods__["CreateInstance"] = lambda x: _znc_core.CZNC_CreateInstance
    if _newclass:
        CreateInstance = staticmethod(_znc_core.CZNC_CreateInstance)
    __swig_getmethods__["Get"] = lambda x: _znc_core.CZNC_Get
    if _newclass:
        Get = staticmethod(_znc_core.CZNC_Get)
    __swig_getmethods__["DestroyInstance"] = lambda x: _znc_core.CZNC_DestroyInstance
    if _newclass:
        DestroyInstance = staticmethod(_znc_core.CZNC_DestroyInstance)

    def FindUser(self, sUsername: 'CString const &') -> "CUser *":
        return _znc_core.CZNC_FindUser(self, sUsername)

    def FindModule(self, *args) -> "CModule *":
        return _znc_core.CZNC_FindModule(self, *args)

    def UpdateModule(self, sModule: 'CString const &') -> "bool":
        return _znc_core.CZNC_UpdateModule(self, sModule)

    def DeleteUser(self, sUsername: 'CString const &') -> "bool":
        return _znc_core.CZNC_DeleteUser(self, sUsername)

    def AddUser(self, pUser: 'CUser', sErrorRet: 'CString &') -> "bool":
        return _znc_core.CZNC_AddUser(self, pUser, sErrorRet)

    def GetUserMap(self) -> "std::map< CString,CUser *,std::less< CString >,std::allocator< std::pair< CString const,CUser * > > > const &":
        return _znc_core.CZNC_GetUserMap(self)

    def FindListener(self, uPort: 'unsigned short', BindHost: 'CString const &', eAddr: 'EAddrType') -> "CListener *":
        return _znc_core.CZNC_FindListener(self, uPort, BindHost, eAddr)

    def AddListener(self, *args) -> "bool":
        return _znc_core.CZNC_AddListener(self, *args)

    def DelListener(self, arg2: 'CListener') -> "bool":
        return _znc_core.CZNC_DelListener(self, arg2)

    def SetMotd(self, sMessage: 'CString const &') -> "void":
        return _znc_core.CZNC_SetMotd(self, sMessage)

    def AddMotd(self, sMessage: 'CString const &') -> "void":
        return _znc_core.CZNC_AddMotd(self, sMessage)

    def ClearMotd(self) -> "void":
        return _znc_core.CZNC_ClearMotd(self)

    def GetMotd(self) -> "VCString const &":
        return _znc_core.CZNC_GetMotd(self)

    def AddServerThrottle(self, sName: 'CString') -> "void":
        return _znc_core.CZNC_AddServerThrottle(self, sName)

    def GetServerThrottle(self, *args) -> "bool":
        return _znc_core.CZNC_GetServerThrottle(self, *args)

    def AddNetworkToQueue(self, pNetwork: 'CIRCNetwork') -> "void":
        return _znc_core.CZNC_AddNetworkToQueue(self, pNetwork)

    def GetConnectionQueue(self) -> "std::list< CIRCNetwork *,std::allocator< CIRCNetwork * > > &":
        return _znc_core.CZNC_GetConnectionQueue(self)

    def EnableConnectQueue(self) -> "void":
        return _znc_core.CZNC_EnableConnectQueue(self)

    def DisableConnectQueue(self) -> "void":
        return _znc_core.CZNC_DisableConnectQueue(self)

    def PauseConnectQueue(self) -> "void":
        return _znc_core.CZNC_PauseConnectQueue(self)

    def ResumeConnectQueue(self) -> "void":
        return _znc_core.CZNC_ResumeConnectQueue(self)

    def LeakConnectQueueTimer(self, pTimer: 'CConnectQueueTimer *') -> "void":
        return _znc_core.CZNC_LeakConnectQueueTimer(self, pTimer)
    __swig_getmethods__["DumpConfig"] = lambda x: _znc_core.CZNC_DumpConfig
    if _newclass:
        DumpConfig = staticmethod(_znc_core.CZNC_DumpConfig)

    def GetUserMap_(self) -> "PyObject *":
        return _znc_core.CZNC_GetUserMap_(self)
CZNC_swigregister = _znc_core.CZNC_swigregister
CZNC_swigregister(CZNC)

def CZNC_GetVersion() -> "CString":
    return _znc_core.CZNC_GetVersion()
CZNC_GetVersion = _znc_core.CZNC_GetVersion

def CZNC_GetTag(bIncludeVersion: 'bool'=True, bHTML: 'bool'=False) -> "CString":
    return _znc_core.CZNC_GetTag(bIncludeVersion, bHTML)
CZNC_GetTag = _znc_core.CZNC_GetTag

def CZNC_GetCompileOptionsString() -> "CString":
    return _znc_core.CZNC_GetCompileOptionsString()
CZNC_GetCompileOptionsString = _znc_core.CZNC_GetCompileOptionsString

def CZNC_CreateInstance() -> "void":
    return _znc_core.CZNC_CreateInstance()
CZNC_CreateInstance = _znc_core.CZNC_CreateInstance

def CZNC_Get() -> "CZNC &":
    return _znc_core.CZNC_Get()
CZNC_Get = _znc_core.CZNC_Get

def CZNC_DestroyInstance() -> "void":
    return _znc_core.CZNC_DestroyInstance()
CZNC_DestroyInstance = _znc_core.CZNC_DestroyInstance

def CZNC_DumpConfig(Config: 'CConfig') -> "void":
    return _znc_core.CZNC_DumpConfig(Config)
CZNC_DumpConfig = _znc_core.CZNC_DumpConfig

class CServer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CServer, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CServer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CServer
    __del__ = lambda self: None

    def GetName(self) -> "CString const &":
        return _znc_core.CServer_GetName(self)

    def GetPort(self) -> "unsigned short":
        return _znc_core.CServer_GetPort(self)

    def GetPass(self) -> "CString const &":
        return _znc_core.CServer_GetPass(self)

    def IsSSL(self) -> "bool":
        return _znc_core.CServer_IsSSL(self)

    def GetString(self, bIncludePassword: 'bool'=True) -> "CString":
        return _znc_core.CServer_GetString(self, bIncludePassword)
    __swig_getmethods__["IsValidHostName"] = lambda x: _znc_core.CServer_IsValidHostName
    if _newclass:
        IsValidHostName = staticmethod(_znc_core.CServer_IsValidHostName)
CServer_swigregister = _znc_core.CServer_swigregister
CServer_swigregister(CServer)

def CServer_IsValidHostName(sHostName: 'CString const &') -> "bool":
    return _znc_core.CServer_IsValidHostName(sHostName)
CServer_IsValidHostName = _znc_core.CServer_IsValidHostName

class CDebug(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CDebug, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CDebug, name)
    __repr__ = _swig_repr
    __swig_getmethods__["SetStdoutIsTTY"] = lambda x: _znc_core.CDebug_SetStdoutIsTTY
    if _newclass:
        SetStdoutIsTTY = staticmethod(_znc_core.CDebug_SetStdoutIsTTY)
    __swig_getmethods__["StdoutIsTTY"] = lambda x: _znc_core.CDebug_StdoutIsTTY
    if _newclass:
        StdoutIsTTY = staticmethod(_znc_core.CDebug_StdoutIsTTY)
    __swig_getmethods__["SetDebug"] = lambda x: _znc_core.CDebug_SetDebug
    if _newclass:
        SetDebug = staticmethod(_znc_core.CDebug_SetDebug)
    __swig_getmethods__["Debug"] = lambda x: _znc_core.CDebug_Debug
    if _newclass:
        Debug = staticmethod(_znc_core.CDebug_Debug)

    def __init__(self):
        this = _znc_core.new_CDebug()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CDebug
    __del__ = lambda self: None
CDebug_swigregister = _znc_core.CDebug_swigregister
CDebug_swigregister(CDebug)

def CDebug_SetStdoutIsTTY(b: 'bool') -> "void":
    return _znc_core.CDebug_SetStdoutIsTTY(b)
CDebug_SetStdoutIsTTY = _znc_core.CDebug_SetStdoutIsTTY

def CDebug_StdoutIsTTY() -> "bool":
    return _znc_core.CDebug_StdoutIsTTY()
CDebug_StdoutIsTTY = _znc_core.CDebug_StdoutIsTTY

def CDebug_SetDebug(b: 'bool') -> "void":
    return _znc_core.CDebug_SetDebug(b)
CDebug_SetDebug = _znc_core.CDebug_SetDebug

def CDebug_Debug() -> "bool":
    return _znc_core.CDebug_Debug()
CDebug_Debug = _znc_core.CDebug_Debug

class CDebugStream(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CDebugStream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CDebugStream, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _znc_core.delete_CDebugStream
    __del__ = lambda self: None

    def __init__(self):
        this = _znc_core.new_CDebugStream()
        try:
            self.this.append(this)
        except:
            self.this = this
CDebugStream_swigregister = _znc_core.CDebugStream_swigregister
CDebugStream_swigregister(CDebugStream)

class CExecSock(CZNCSock):
    __swig_setmethods__ = {}
    for _s in [CZNCSock]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CExecSock, name, value)
    __swig_getmethods__ = {}
    for _s in [CZNCSock]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CExecSock, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _znc_core.new_CExecSock()
        try:
            self.this.append(this)
        except:
            self.this = this

    def Execute(self, sExec: 'CString const &') -> "int":
        return _znc_core.CExecSock_Execute(self, sExec)

    def Kill(self, iSignal: 'int') -> "void":
        return _znc_core.CExecSock_Kill(self, iSignal)
    __swig_destroy__ = _znc_core.delete_CExecSock
    __del__ = lambda self: None

    def popen2(self, iReadFD: 'int &', iWriteFD: 'int &', sCommand: 'CString const &') -> "int":
        return _znc_core.CExecSock_popen2(self, iReadFD, iWriteFD, sCommand)

    def close2(self, iPid: 'int', iReadFD: 'int', iWriteFD: 'int') -> "void":
        return _znc_core.CExecSock_close2(self, iPid, iReadFD, iWriteFD)
CExecSock_swigregister = _znc_core.CExecSock_swigregister
CExecSock_swigregister(CExecSock)

class CBufLine(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CBufLine, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CBufLine, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_CBufLine(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CBufLine
    __del__ = lambda self: None

    def GetLine(self, Client: 'CClient', msParams: 'MCString') -> "CString":
        return _znc_core.CBufLine_GetLine(self, Client, msParams)

    def UpdateTime(self) -> "void":
        return _znc_core.CBufLine_UpdateTime(self)

    def SetFormat(self, sFormat: 'CString const &') -> "void":
        return _znc_core.CBufLine_SetFormat(self, sFormat)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CBufLine_SetText(self, sText)

    def SetTime(self, ts: 'timeval const &') -> "void":
        return _znc_core.CBufLine_SetTime(self, ts)

    def GetFormat(self) -> "CString const &":
        return _znc_core.CBufLine_GetFormat(self)

    def GetText(self) -> "CString const &":
        return _znc_core.CBufLine_GetText(self)

    def GetTime(self) -> "timeval":
        return _znc_core.CBufLine_GetTime(self)
CBufLine_swigregister = _znc_core.CBufLine_swigregister
CBufLine_swigregister(CBufLine)

class CBuffer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CBuffer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CBuffer, name)
    __repr__ = _swig_repr

    def __init__(self, uLineCount: 'unsigned int'=100):
        this = _znc_core.new_CBuffer(uLineCount)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_CBuffer
    __del__ = lambda self: None

    def AddLine(self, *args) -> "std::deque< CBufLine >::size_type":
        return _znc_core.CBuffer_AddLine(self, *args)

    def UpdateLine(self, *args) -> "std::deque< CBufLine >::size_type":
        return _znc_core.CBuffer_UpdateLine(self, *args)

    def UpdateExactLine(self, *args) -> "std::deque< CBufLine >::size_type":
        return _znc_core.CBuffer_UpdateExactLine(self, *args)

    def GetBufLine(self, uIdx: 'unsigned int') -> "CBufLine const &":
        return _znc_core.CBuffer_GetBufLine(self, uIdx)

    def GetLine(self, *args) -> "CString":
        return _znc_core.CBuffer_GetLine(self, *args)

    def Size(self) -> "std::deque< CBufLine >::size_type":
        return _znc_core.CBuffer_Size(self)

    def IsEmpty(self) -> "bool":
        return _znc_core.CBuffer_IsEmpty(self)

    def Clear(self) -> "void":
        return _znc_core.CBuffer_Clear(self)

    def SetLineCount(self, u: 'unsigned int', bForce: 'bool'=False) -> "bool":
        return _znc_core.CBuffer_SetLineCount(self, u, bForce)

    def GetLineCount(self) -> "unsigned int":
        return _znc_core.CBuffer_GetLineCount(self)
CBuffer_swigregister = _znc_core.CBuffer_swigregister
CBuffer_swigregister(CBuffer)

class String(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, String, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, String, name)
    __repr__ = _swig_repr
    __swig_setmethods__["s"] = _znc_core.String_s_set
    __swig_getmethods__["s"] = _znc_core.String_s_get
    if _newclass:
        s = _swig_property(_znc_core.String_s_get, _znc_core.String_s_set)

    def __str__(self) -> "CString":
        return _znc_core.String___str__(self)

    def __init__(self):
        this = _znc_core.new_String()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _znc_core.delete_String
    __del__ = lambda self: None
String_swigregister = _znc_core.String_swigregister
String_swigregister(String)

class CPyModule(CModule):
    __swig_setmethods__ = {}
    for _s in [CModule]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPyModule, name, value)
    __swig_getmethods__ = {}
    for _s in [CModule]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CPyModule, name)
    __repr__ = _swig_repr

    def __init__(self, pUser: 'CUser', pNetwork: 'CIRCNetwork', sModName: 'CString const &', sDataPath: 'CString const &', pyObj: 'PyObject *', pModPython: 'CModPython'):
        this = _znc_core.new_CPyModule(pUser, pNetwork, sModName, sDataPath, pyObj, pModPython)
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetPyObj(self) -> "PyObject *":
        return _znc_core.CPyModule_GetPyObj(self)

    def GetNewPyObj(self) -> "PyObject *":
        return _znc_core.CPyModule_GetNewPyObj(self)

    def DeletePyModule(self) -> "void":
        return _znc_core.CPyModule_DeletePyModule(self)

    def GetPyExceptionStr(self) -> "CString":
        return _znc_core.CPyModule_GetPyExceptionStr(self)

    def GetModPython(self) -> "CModPython *":
        return _znc_core.CPyModule_GetModPython(self)

    def OnBoot(self) -> "bool":
        return _znc_core.CPyModule_OnBoot(self)

    def WebRequiresLogin(self) -> "bool":
        return _znc_core.CPyModule_WebRequiresLogin(self)

    def WebRequiresAdmin(self) -> "bool":
        return _znc_core.CPyModule_WebRequiresAdmin(self)

    def GetWebMenuTitle(self) -> "CString":
        return _znc_core.CPyModule_GetWebMenuTitle(self)

    def OnWebPreRequest(self, WebSock: 'CWebSock', sPageName: 'CString const &') -> "bool":
        return _znc_core.CPyModule_OnWebPreRequest(self, WebSock, sPageName)

    def OnWebRequest(self, WebSock: 'CWebSock', sPageName: 'CString const &', Tmpl: 'CTemplate') -> "bool":
        return _znc_core.CPyModule_OnWebRequest(self, WebSock, sPageName, Tmpl)

    def GetSubPages(self) -> "VWebSubPages &":
        return _znc_core.CPyModule_GetSubPages(self)

    def OnPreRehash(self) -> "void":
        return _znc_core.CPyModule_OnPreRehash(self)

    def OnPostRehash(self) -> "void":
        return _znc_core.CPyModule_OnPostRehash(self)

    def OnIRCDisconnected(self) -> "void":
        return _znc_core.CPyModule_OnIRCDisconnected(self)

    def OnIRCConnected(self) -> "void":
        return _znc_core.CPyModule_OnIRCConnected(self)

    def OnIRCConnecting(self, pIRCSock: 'CIRCSock') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnIRCConnecting(self, pIRCSock)

    def OnIRCConnectionError(self, pIRCSock: 'CIRCSock') -> "void":
        return _znc_core.CPyModule_OnIRCConnectionError(self, pIRCSock)

    def OnIRCRegistration(self, sPass: 'CString &', sNick: 'CString &', sIdent: 'CString &', sRealName: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnIRCRegistration(self, sPass, sNick, sIdent, sRealName)

    def OnBroadcast(self, sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnBroadcast(self, sMessage)

    def OnChanPermission2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', uMode: 'unsigned char', bAdded: 'bool', bNoChange: 'bool') -> "void":
        return _znc_core.CPyModule_OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnOp2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CPyModule_OnOp2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDeop2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CPyModule_OnDeop2(self, pOpNick, Nick, Channel, bNoChange)

    def OnVoice2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CPyModule_OnVoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDevoice2(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', bNoChange: 'bool') -> "void":
        return _znc_core.CPyModule_OnDevoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnMode2(self, pOpNick: 'CNick', Channel: 'CChan', uMode: 'char', sArg: 'CString const &', bAdded: 'bool', bNoChange: 'bool') -> "void":
        return _znc_core.CPyModule_OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnRawMode2(self, pOpNick: 'CNick', Channel: 'CChan', sModes: 'CString const &', sArgs: 'CString const &') -> "void":
        return _znc_core.CPyModule_OnRawMode2(self, pOpNick, Channel, sModes, sArgs)

    def OnRaw(self, sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnRaw(self, sLine)

    def OnStatusCommand(self, sCommand: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnStatusCommand(self, sCommand)

    def OnModCommand(self, sCommand: 'CString const &') -> "void":
        return _znc_core.CPyModule_OnModCommand(self, sCommand)

    def OnModNotice(self, sMessage: 'CString const &') -> "void":
        return _znc_core.CPyModule_OnModNotice(self, sMessage)

    def OnModCTCP(self, sMessage: 'CString const &') -> "void":
        return _znc_core.CPyModule_OnModCTCP(self, sMessage)

    def OnQuit(self, Nick: 'CNick', sMessage: 'CString const &', vChans: 'VChannels') -> "void":
        return _znc_core.CPyModule_OnQuit(self, Nick, sMessage, vChans)

    def OnNick(self, Nick: 'CNick', sNewNick: 'CString const &', vChans: 'VChannels') -> "void":
        return _znc_core.CPyModule_OnNick(self, Nick, sNewNick, vChans)

    def OnKick(self, OpNick: 'CNick', sKickedNick: 'CString const &', Channel: 'CChan', sMessage: 'CString const &') -> "void":
        return _znc_core.CPyModule_OnKick(self, OpNick, sKickedNick, Channel, sMessage)

    def OnJoining(self, Channel: 'CChan') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnJoining(self, Channel)

    def OnJoin(self, Nick: 'CNick', Channel: 'CChan') -> "void":
        return _znc_core.CPyModule_OnJoin(self, Nick, Channel)

    def OnPart(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString const &') -> "void":
        return _znc_core.CPyModule_OnPart(self, Nick, Channel, sMessage)

    def OnInvite(self, Nick: 'CNick', sChan: 'CString const &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnInvite(self, Nick, sChan)

    def OnChanBufferStarting(self, Chan: 'CChan', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanBufferStarting(self, Chan, Client)

    def OnChanBufferEnding(self, Chan: 'CChan', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanBufferEnding(self, Chan, Client)

    def OnChanBufferPlayLine(self, Chan: 'CChan', Client: 'CClient', sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanBufferPlayLine(self, Chan, Client, sLine)

    def OnPrivBufferPlayLine(self, Client: 'CClient', sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivBufferPlayLine(self, Client, sLine)

    def OnClientLogin(self) -> "void":
        return _znc_core.CPyModule_OnClientLogin(self)

    def OnClientDisconnect(self) -> "void":
        return _znc_core.CPyModule_OnClientDisconnect(self)

    def OnUserRaw(self, sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserRaw(self, sLine)

    def OnUserCTCPReply(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserCTCPReply(self, sTarget, sMessage)

    def OnUserCTCP(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserCTCP(self, sTarget, sMessage)

    def OnUserAction(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserAction(self, sTarget, sMessage)

    def OnUserMsg(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserMsg(self, sTarget, sMessage)

    def OnUserNotice(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserNotice(self, sTarget, sMessage)

    def OnUserJoin(self, sChannel: 'CString &', sKey: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserJoin(self, sChannel, sKey)

    def OnUserPart(self, sChannel: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserPart(self, sChannel, sMessage)

    def OnUserTopic(self, sChannel: 'CString &', sTopic: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserTopic(self, sChannel, sTopic)

    def OnUserTopicRequest(self, sChannel: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserTopicRequest(self, sChannel)

    def OnCTCPReply(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnCTCPReply(self, Nick, sMessage)

    def OnPrivCTCP(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivCTCP(self, Nick, sMessage)

    def OnChanCTCP(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanCTCP(self, Nick, Channel, sMessage)

    def OnPrivAction(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivAction(self, Nick, sMessage)

    def OnChanAction(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanAction(self, Nick, Channel, sMessage)

    def OnPrivMsg(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivMsg(self, Nick, sMessage)

    def OnChanMsg(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanMsg(self, Nick, Channel, sMessage)

    def OnPrivNotice(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivNotice(self, Nick, sMessage)

    def OnChanNotice(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanNotice(self, Nick, Channel, sMessage)

    def OnTopic(self, Nick: 'CNick', Channel: 'CChan', sTopic: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnTopic(self, Nick, Channel, sTopic)

    def OnServerCapAvailable(self, sCap: 'CString const &') -> "bool":
        return _znc_core.CPyModule_OnServerCapAvailable(self, sCap)

    def OnServerCapResult(self, sCap: 'CString const &', bSuccess: 'bool') -> "void":
        return _znc_core.CPyModule_OnServerCapResult(self, sCap, bSuccess)

    def OnTimerAutoJoin(self, Channel: 'CChan') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnTimerAutoJoin(self, Channel)

    def OnEmbeddedWebRequest(self, arg2: 'CWebSock', arg3: 'CString const &', arg4: 'CTemplate') -> "bool":
        return _znc_core.CPyModule_OnEmbeddedWebRequest(self, arg2, arg3, arg4)

    def OnAddNetwork(self, Network: 'CIRCNetwork', sErrorRet: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnAddNetwork(self, Network, sErrorRet)

    def OnDeleteNetwork(self, Network: 'CIRCNetwork') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnDeleteNetwork(self, Network)

    def OnSendToClient(self, sLine: 'CString &', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnSendToClient(self, sLine, Client)

    def OnSendToIRC(self, sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnSendToIRC(self, sLine)

    def OnAddUser(self, User: 'CUser', sErrorRet: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnAddUser(self, User, sErrorRet)

    def OnDeleteUser(self, User: 'CUser') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnDeleteUser(self, User)

    def OnClientConnect(self, pSock: 'CZNCSock', sHost: 'CString const &', uPort: 'unsigned short') -> "void":
        return _znc_core.CPyModule_OnClientConnect(self, pSock, sHost, uPort)

    def OnFailedLogin(self, sUsername: 'CString const &', sRemoteIP: 'CString const &') -> "void":
        return _znc_core.CPyModule_OnFailedLogin(self, sUsername, sRemoteIP)

    def OnUnknownUserRaw(self, pClient: 'CClient', sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUnknownUserRaw(self, pClient, sLine)

    def IsClientCapSupported(self, pClient: 'CClient', sCap: 'CString const &', bState: 'bool') -> "bool":
        return _znc_core.CPyModule_IsClientCapSupported(self, pClient, sCap, bState)

    def OnClientCapRequest(self, pClient: 'CClient', sCap: 'CString const &', bState: 'bool') -> "void":
        return _znc_core.CPyModule_OnClientCapRequest(self, pClient, sCap, bState)

    def OnModuleLoading(self, sModName: 'CString const &', sArgs: 'CString const &', eType: 'CModInfo::EModuleType', bSuccess: 'bool &', sRetMsg: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg)

    def OnModuleUnloading(self, pModule: 'CModule', bSuccess: 'bool &', sRetMsg: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnModuleUnloading(self, pModule, bSuccess, sRetMsg)

    def OnGetModInfo(self, ModInfo: 'CModInfo', sModule: 'CString const &', bSuccess: 'bool &', sRetMsg: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg)

    def OnGetAvailableMods(self, ssMods: 'SModInfo', eType: 'CModInfo::EModuleType') -> "void":
        return _znc_core.CPyModule_OnGetAvailableMods(self, ssMods, eType)

    def OnClientCapLs(self, pClient: 'CClient', ssCaps: 'SCString') -> "void":
        return _znc_core.CPyModule_OnClientCapLs(self, pClient, ssCaps)

    def OnLoginAttempt(self, Auth: 'std::shared_ptr< CAuthBase >') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnLoginAttempt(self, Auth)
    __swig_destroy__ = _znc_core.delete_CPyModule
    __del__ = lambda self: None
CPyModule_swigregister = _znc_core.CPyModule_swigregister
CPyModule_swigregister(CPyModule)


def AsPyModule(p: 'CModule') -> "CPyModule *":
    return _znc_core.AsPyModule(p)
AsPyModule = _znc_core.AsPyModule

def CreatePyModule(pUser: 'CUser', pNetwork: 'CIRCNetwork', sModName: 'CString const &', sDataPath: 'CString const &', pyObj: 'PyObject *', pModPython: 'CModPython') -> "CPyModule *":
    return _znc_core.CreatePyModule(pUser, pNetwork, sModName, sDataPath, pyObj, pModPython)
CreatePyModule = _znc_core.CreatePyModule
class CPyTimer(CTimer):
    __swig_setmethods__ = {}
    for _s in [CTimer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPyTimer, name, value)
    __swig_getmethods__ = {}
    for _s in [CTimer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CPyTimer, name)
    __repr__ = _swig_repr

    def __init__(self, pModule: 'CPyModule', uInterval: 'unsigned int', uCycles: 'unsigned int', sLabel: 'CString const &', sDescription: 'CString const &', pyObj: 'PyObject *'):
        this = _znc_core.new_CPyTimer(pModule, uInterval, uCycles, sLabel, sDescription, pyObj)
        try:
            self.this.append(this)
        except:
            self.this = this

    def RunJob(self) -> "void":
        return _znc_core.CPyTimer_RunJob(self)

    def GetPyObj(self) -> "PyObject *":
        return _znc_core.CPyTimer_GetPyObj(self)

    def GetNewPyObj(self) -> "PyObject *":
        return _znc_core.CPyTimer_GetNewPyObj(self)
    __swig_destroy__ = _znc_core.delete_CPyTimer
    __del__ = lambda self: None
CPyTimer_swigregister = _znc_core.CPyTimer_swigregister
CPyTimer_swigregister(CPyTimer)


def CreatePyTimer(pModule: 'CPyModule', uInterval: 'unsigned int', uCycles: 'unsigned int', sLabel: 'CString const &', sDescription: 'CString const &', pyObj: 'PyObject *') -> "CPyTimer *":
    return _znc_core.CreatePyTimer(pModule, uInterval, uCycles, sLabel, sDescription, pyObj)
CreatePyTimer = _znc_core.CreatePyTimer
class CPySocket(CSocket):
    __swig_setmethods__ = {}
    for _s in [CSocket]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPySocket, name, value)
    __swig_getmethods__ = {}
    for _s in [CSocket]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CPySocket, name)
    __repr__ = _swig_repr

    def __init__(self, pModule: 'CPyModule', pyObj: 'PyObject *'):
        this = _znc_core.new_CPySocket(pModule, pyObj)
        try:
            self.this.append(this)
        except:
            self.this = this

    def GetPyObj(self) -> "PyObject *":
        return _znc_core.CPySocket_GetPyObj(self)

    def GetNewPyObj(self) -> "PyObject *":
        return _znc_core.CPySocket_GetNewPyObj(self)
    __swig_destroy__ = _znc_core.delete_CPySocket
    __del__ = lambda self: None

    def Connected(self) -> "void":
        return _znc_core.CPySocket_Connected(self)

    def Disconnected(self) -> "void":
        return _znc_core.CPySocket_Disconnected(self)

    def Timeout(self) -> "void":
        return _znc_core.CPySocket_Timeout(self)

    def ConnectionRefused(self) -> "void":
        return _znc_core.CPySocket_ConnectionRefused(self)

    def ReadData(self, data: 'char const *', len: 'size_t') -> "void":
        return _znc_core.CPySocket_ReadData(self, data, len)

    def ReadLine(self, sLine: 'CString const &') -> "void":
        return _znc_core.CPySocket_ReadLine(self, sLine)

    def GetSockObj(self, sHost: 'CString const &', uPort: 'unsigned short') -> "Csock *":
        return _znc_core.CPySocket_GetSockObj(self, sHost, uPort)
CPySocket_swigregister = _znc_core.CPySocket_swigregister
CPySocket_swigregister(CPySocket)


def CreatePySocket(pModule: 'CPyModule', pyObj: 'PyObject *') -> "CPySocket *":
    return _znc_core.CreatePySocket(pModule, pyObj)
CreatePySocket = _znc_core.CreatePySocket

def HaveIPv6_() -> "bool":
    return _znc_core.HaveIPv6_()
HaveIPv6_ = _znc_core.HaveIPv6_

def HaveSSL_() -> "bool":
    return _znc_core.HaveSSL_()
HaveSSL_ = _znc_core.HaveSSL_

def HaveCharset_() -> "bool":
    return _znc_core.HaveCharset_()
HaveCharset_ = _znc_core.HaveCharset_

def GetSOMAXCONN() -> "int":
    return _znc_core.GetSOMAXCONN()
GetSOMAXCONN = _znc_core.GetSOMAXCONN

def GetVersionMajor() -> "int":
    return _znc_core.GetVersionMajor()
GetVersionMajor = _znc_core.GetVersionMajor

def GetVersionMinor() -> "int":
    return _znc_core.GetVersionMinor()
GetVersionMinor = _znc_core.GetVersionMinor

def GetVersion() -> "double":
    return _znc_core.GetVersion()
GetVersion = _znc_core.GetVersion

def GetVersionExtra() -> "CString":
    return _znc_core.GetVersionExtra()
GetVersionExtra = _znc_core.GetVersionExtra
class MCString_iter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCString_iter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MCString_iter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _znc_core.MCString_iter_x_set
    __swig_getmethods__["x"] = _znc_core.MCString_iter_x_get
    if _newclass:
        x = _swig_property(_znc_core.MCString_iter_x_get, _znc_core.MCString_iter_x_set)

    def __init__(self, *args):
        this = _znc_core.new_MCString_iter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def plusplus(self) -> "void":
        return _znc_core.MCString_iter_plusplus(self)

    def get(self) -> "CString":
        return _znc_core.MCString_iter_get(self)

    def is_end(self, m: 'CModule') -> "bool":
        return _znc_core.MCString_iter_is_end(self, m)
    __swig_destroy__ = _znc_core.delete_MCString_iter
    __del__ = lambda self: None
MCString_iter_swigregister = _znc_core.MCString_iter_swigregister
MCString_iter_swigregister(MCString_iter)

class CModulesIter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CModulesIter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CModulesIter, name)
    __repr__ = _swig_repr

    def __init__(self, pModules: 'CModules'):
        this = _znc_core.new_CModulesIter(pModules)
        try:
            self.this.append(this)
        except:
            self.this = this

    def plusplus(self) -> "void":
        return _znc_core.CModulesIter_plusplus(self)

    def get(self) -> "CModule const *":
        return _znc_core.CModulesIter_get(self)

    def is_end(self) -> "bool":
        return _znc_core.CModulesIter_is_end(self)
    __swig_setmethods__["m_pModules"] = _znc_core.CModulesIter_m_pModules_set
    __swig_getmethods__["m_pModules"] = _znc_core.CModulesIter_m_pModules_get
    if _newclass:
        m_pModules = _swig_property(_znc_core.CModulesIter_m_pModules_get, _znc_core.CModulesIter_m_pModules_set)
    __swig_setmethods__["m_it"] = _znc_core.CModulesIter_m_it_set
    __swig_getmethods__["m_it"] = _znc_core.CModulesIter_m_it_get
    if _newclass:
        m_it = _swig_property(_znc_core.CModulesIter_m_it_get, _znc_core.CModulesIter_m_it_set)
    __swig_destroy__ = _znc_core.delete_CModulesIter
    __del__ = lambda self: None
CModulesIter_swigregister = _znc_core.CModulesIter_swigregister
CModulesIter_swigregister(CModulesIter)

class CPyRetString(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPyRetString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPyRetString, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["s"] = _znc_core.CPyRetString_s_set
    __swig_getmethods__["s"] = _znc_core.CPyRetString_s_get
    if _newclass:
        s = _swig_property(_znc_core.CPyRetString_s_get, _znc_core.CPyRetString_s_set)

    def __str__(self) -> "CString":
        return _znc_core.CPyRetString___str__(self)
    __swig_destroy__ = _znc_core.delete_CPyRetString
    __del__ = lambda self: None
CPyRetString_swigregister = _znc_core.CPyRetString_swigregister
CPyRetString_swigregister(CPyRetString)

class CPyRetBool(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPyRetBool, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPyRetBool, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["b"] = _znc_core.CPyRetBool_b_set
    __swig_getmethods__["b"] = _znc_core.CPyRetBool_b_get
    if _newclass:
        b = _swig_property(_znc_core.CPyRetBool_b_get, _znc_core.CPyRetBool_b_set)

    def __bool__(self) -> "bool":
        return _znc_core.CPyRetBool___bool__(self)
    __swig_destroy__ = _znc_core.delete_CPyRetBool
    __del__ = lambda self: None
CPyRetBool_swigregister = _znc_core.CPyRetBool_swigregister
CPyRetBool_swigregister(CPyRetBool)

class CModPython(CModule):
    __swig_setmethods__ = {}
    for _s in [CModule]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CModPython, name, value)
    __swig_getmethods__ = {}
    for _s in [CModule]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CModPython, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
CModPython_swigregister = _znc_core.CModPython_swigregister
CModPython_swigregister(CModPython)

class StrPair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StrPair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StrPair, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _znc_core.new_StrPair(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["first"] = _znc_core.StrPair_first_set
    __swig_getmethods__["first"] = _znc_core.StrPair_first_get
    if _newclass:
        first = _swig_property(_znc_core.StrPair_first_get, _znc_core.StrPair_first_set)
    __swig_setmethods__["second"] = _znc_core.StrPair_second_set
    __swig_getmethods__["second"] = _znc_core.StrPair_second_get
    if _newclass:
        second = _swig_property(_znc_core.StrPair_second_get, _znc_core.StrPair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _znc_core.delete_StrPair
    __del__ = lambda self: None
StrPair_swigregister = _znc_core.StrPair_swigregister
StrPair_swigregister(StrPair)

class VPair(collections.MutableSequence):
    __swig_setmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VPair, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VPair, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.VPair_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.VPair___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.VPair___bool__(self)

    def __len__(self) -> "std::vector< std::pair< CString,CString > >::size_type":
        return _znc_core.VPair___len__(self)

    def pop(self) -> "std::vector< std::pair< CString,CString > >::value_type":
        return _znc_core.VPair_pop(self)

    def __getslice__(self, i: 'std::vector< std::pair< CString,CString > >::difference_type', j: 'std::vector< std::pair< CString,CString > >::difference_type') -> "std::vector< std::pair< CString,CString >,std::allocator< std::pair< CString,CString > > > *":
        return _znc_core.VPair___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.VPair___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< std::pair< CString,CString > >::difference_type', j: 'std::vector< std::pair< CString,CString > >::difference_type') -> "void":
        return _znc_core.VPair___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.VPair___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::pair< CString,CString > >::value_type const &":
        return _znc_core.VPair___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.VPair___setitem__(self, *args)

    def append(self, x: 'StrPair') -> "void":
        return _znc_core.VPair_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.VPair_empty(self)

    def size(self) -> "std::vector< std::pair< CString,CString > >::size_type":
        return _znc_core.VPair_size(self)

    def clear(self) -> "void":
        return _znc_core.VPair_clear(self)

    def swap(self, v: 'VPair') -> "void":
        return _znc_core.VPair_swap(self, v)

    def get_allocator(self) -> "std::vector< std::pair< CString,CString > >::allocator_type":
        return _znc_core.VPair_get_allocator(self)

    def begin(self) -> "std::vector< std::pair< CString,CString > >::iterator":
        return _znc_core.VPair_begin(self)

    def end(self) -> "std::vector< std::pair< CString,CString > >::iterator":
        return _znc_core.VPair_end(self)

    def rbegin(self) -> "std::vector< std::pair< CString,CString > >::reverse_iterator":
        return _znc_core.VPair_rbegin(self)

    def rend(self) -> "std::vector< std::pair< CString,CString > >::reverse_iterator":
        return _znc_core.VPair_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.VPair_pop_back(self)

    def erase(self, *args) -> "std::vector< std::pair< CString,CString > >::iterator":
        return _znc_core.VPair_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_VPair(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'StrPair') -> "void":
        return _znc_core.VPair_push_back(self, x)

    def front(self) -> "std::vector< std::pair< CString,CString > >::value_type const &":
        return _znc_core.VPair_front(self)

    def back(self) -> "std::vector< std::pair< CString,CString > >::value_type const &":
        return _znc_core.VPair_back(self)

    def assign(self, n: 'std::vector< std::pair< CString,CString > >::size_type', x: 'StrPair') -> "void":
        return _znc_core.VPair_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.VPair_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.VPair_insert(self, *args)

    def reserve(self, n: 'std::vector< std::pair< CString,CString > >::size_type') -> "void":
        return _znc_core.VPair_reserve(self, n)

    def capacity(self) -> "std::vector< std::pair< CString,CString > >::size_type":
        return _znc_core.VPair_capacity(self)
    __swig_destroy__ = _znc_core.delete_VPair
    __del__ = lambda self: None
VPair_swigregister = _znc_core.VPair_swigregister
VPair_swigregister(VPair)

class VWebSubPages(collections.MutableSequence):
    __swig_setmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VWebSubPages, name, value)
    __swig_getmethods__ = {}
    for _s in [collections.MutableSequence]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VWebSubPages, name)
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _znc_core.VWebSubPages_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _znc_core.VWebSubPages___nonzero__(self)

    def __bool__(self) -> "bool":
        return _znc_core.VWebSubPages___bool__(self)

    def __len__(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::size_type":
        return _znc_core.VWebSubPages___len__(self)

    def pop(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::value_type":
        return _znc_core.VWebSubPages_pop(self)

    def __getslice__(self, i: 'std::vector< std::shared_ptr< CWebSubPage > >::difference_type', j: 'std::vector< std::shared_ptr< CWebSubPage > >::difference_type') -> "std::vector< std::shared_ptr< CWebSubPage >,std::allocator< std::shared_ptr< CWebSubPage > > > *":
        return _znc_core.VWebSubPages___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _znc_core.VWebSubPages___setslice__(self, *args)

    def __delslice__(self, i: 'std::vector< std::shared_ptr< CWebSubPage > >::difference_type', j: 'std::vector< std::shared_ptr< CWebSubPage > >::difference_type') -> "void":
        return _znc_core.VWebSubPages___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _znc_core.VWebSubPages___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::shared_ptr< CWebSubPage > >::value_type const &":
        return _znc_core.VWebSubPages___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _znc_core.VWebSubPages___setitem__(self, *args)

    def append(self, x: 'std::vector< std::shared_ptr< CWebSubPage > >::value_type const &') -> "void":
        return _znc_core.VWebSubPages_append(self, x)

    def empty(self) -> "bool":
        return _znc_core.VWebSubPages_empty(self)

    def size(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::size_type":
        return _znc_core.VWebSubPages_size(self)

    def clear(self) -> "void":
        return _znc_core.VWebSubPages_clear(self)

    def swap(self, v: 'VWebSubPages') -> "void":
        return _znc_core.VWebSubPages_swap(self, v)

    def get_allocator(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::allocator_type":
        return _znc_core.VWebSubPages_get_allocator(self)

    def begin(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::iterator":
        return _znc_core.VWebSubPages_begin(self)

    def end(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::iterator":
        return _znc_core.VWebSubPages_end(self)

    def rbegin(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::reverse_iterator":
        return _znc_core.VWebSubPages_rbegin(self)

    def rend(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::reverse_iterator":
        return _znc_core.VWebSubPages_rend(self)

    def pop_back(self) -> "void":
        return _znc_core.VWebSubPages_pop_back(self)

    def erase(self, *args) -> "std::vector< std::shared_ptr< CWebSubPage > >::iterator":
        return _znc_core.VWebSubPages_erase(self, *args)

    def __init__(self, *args):
        this = _znc_core.new_VWebSubPages(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x: 'std::vector< std::shared_ptr< CWebSubPage > >::value_type const &') -> "void":
        return _znc_core.VWebSubPages_push_back(self, x)

    def front(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::value_type const &":
        return _znc_core.VWebSubPages_front(self)

    def back(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::value_type const &":
        return _znc_core.VWebSubPages_back(self)

    def assign(self, n: 'std::vector< std::shared_ptr< CWebSubPage > >::size_type', x: 'std::vector< std::shared_ptr< CWebSubPage > >::value_type const &') -> "void":
        return _znc_core.VWebSubPages_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _znc_core.VWebSubPages_resize(self, *args)

    def insert(self, *args) -> "void":
        return _znc_core.VWebSubPages_insert(self, *args)

    def reserve(self, n: 'std::vector< std::shared_ptr< CWebSubPage > >::size_type') -> "void":
        return _znc_core.VWebSubPages_reserve(self, n)

    def capacity(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::size_type":
        return _znc_core.VWebSubPages_capacity(self)
    __swig_destroy__ = _znc_core.delete_VWebSubPages
    __del__ = lambda self: None
VWebSubPages_swigregister = _znc_core.VWebSubPages_swigregister
VWebSubPages_swigregister(VWebSubPages)


def VPair_Add2Str_(arg1: 'VPair', a: 'CString const &', b: 'CString const &') -> "void":
    return _znc_core.VPair_Add2Str_(arg1, a, b)
VPair_Add2Str_ = _znc_core.VPair_Add2Str_

def CreateWebSubPage_(sName: 'CString const &', sTitle: 'CString const &', vParams: 'VPair', uFlags: 'unsigned int') -> "TWebSubPage":
    return _znc_core.CreateWebSubPage_(sName, sTitle, vParams, uFlags)
CreateWebSubPage_ = _znc_core.CreateWebSubPage_
# This file is compatible with both classic and new-style classes.


