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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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:
        object.__setattr__(self, 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(self, class_type, name):
    if name == "thisown":
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


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


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


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


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


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

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

    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

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

SHARED_PTR_DISOWN = _znc_core.SHARED_PTR_DISOWN
class _stringlist(collections.abc.MutableSequence):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::list< CString >::value_type":
        return _znc_core._stringlist_pop(self)

    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 swap(self, v: '_stringlist') -> "void":
        return _znc_core._stringlist_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core._stringlist_clear(self)

    def get_allocator(self) -> "std::list< CString >::allocator_type":
        return _znc_core._stringlist_get_allocator(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):
        _znc_core._stringlist_swiginit(self, _znc_core.new__stringlist(*args))

    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

# Register _stringlist in _znc_core:
_znc_core._stringlist_swigregister(_stringlist)

class VIRCNetworks(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< CIRCNetwork * >::value_type":
        return _znc_core.VIRCNetworks_pop(self)

    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 swap(self, v: 'VIRCNetworks') -> "void":
        return _znc_core.VIRCNetworks_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.VIRCNetworks_clear(self)

    def get_allocator(self) -> "std::vector< CIRCNetwork * >::allocator_type":
        return _znc_core.VIRCNetworks_get_allocator(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):
        _znc_core.VIRCNetworks_swiginit(self, _znc_core.new_VIRCNetworks(*args))

    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

# Register VIRCNetworks in _znc_core:
_znc_core.VIRCNetworks_swigregister(VIRCNetworks)

class VChannels(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< CChan * >::value_type":
        return _znc_core.VChannels_pop(self)

    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 swap(self, v: 'VChannels') -> "void":
        return _znc_core.VChannels_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.VChannels_clear(self)

    def get_allocator(self) -> "std::vector< CChan * >::allocator_type":
        return _znc_core.VChannels_get_allocator(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):
        _znc_core.VChannels_swiginit(self, _znc_core.new_VChannels(*args))

    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

# Register VChannels in _znc_core:
_znc_core.VChannels_swigregister(VChannels)

class MNicks(collections.abc.MutableMapping):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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):
        _znc_core.MNicks_swiginit(self, _znc_core.new_MNicks(*args))

    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 swap(self, v: 'MNicks') -> "void":
        return _znc_core.MNicks_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.MNicks_clear(self)

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

# Register MNicks in _znc_core:
_znc_core.MNicks_swigregister(MNicks)

class SModInfo(collections.abc.MutableSet):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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):
        _znc_core.SModInfo_swiginit(self, _znc_core.new_SModInfo(*args))

    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

# Register SModInfo in _znc_core:
_znc_core.SModInfo_swigregister(SModInfo)

class SCString(collections.abc.MutableSet):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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):
        _znc_core.SCString_swiginit(self, _znc_core.new_SCString(*args))

    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

# Register SCString in _znc_core:
_znc_core.SCString_swigregister(SCString)

class VCString(collections.abc.MutableSequence):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< CString >::value_type":
        return _znc_core.VCString_pop(self)

    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 swap(self, v: 'VCString') -> "void":
        return _znc_core.VCString_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.VCString_clear(self)

    def get_allocator(self) -> "std::vector< CString >::allocator_type":
        return _znc_core.VCString_get_allocator(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):
        _znc_core.VCString_swiginit(self, _znc_core.new_VCString(*args))

    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

# Register VCString in _znc_core:
_znc_core.VCString_swigregister(VCString)

class PyMCString(collections.abc.MutableMapping):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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):
        _znc_core.PyMCString_swiginit(self, _znc_core.new_PyMCString(*args))

    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 swap(self, v: 'PyMCString') -> "void":
        return _znc_core.PyMCString_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.PyMCString_clear(self)

    def get_allocator(self) -> "std::map< CString,CString >::allocator_type":
        return _znc_core.PyMCString_get_allocator(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

# Register PyMCString in _znc_core:
_znc_core.PyMCString_swigregister(PyMCString)

class PyMStringVString(collections.abc.MutableMapping):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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):
        _znc_core.PyMStringVString_swiginit(self, _znc_core.new_PyMStringVString(*args))

    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 swap(self, v: 'PyMStringVString') -> "void":
        return _znc_core.PyMStringVString_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.PyMStringVString_clear(self)

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

# Register PyMStringVString in _znc_core:
_znc_core.PyMStringVString_swigregister(PyMStringVString)

class MCString(PyMCString):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.MCString_swiginit(self, _znc_core.new_MCString())
    __swig_destroy__ = _znc_core.delete_MCString

# Register MCString in _znc_core:
_znc_core.MCString_swigregister(MCString)

class PyModulesVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< CModule * >::value_type":
        return _znc_core.PyModulesVector_pop(self)

    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 swap(self, v: 'PyModulesVector') -> "void":
        return _znc_core.PyModulesVector_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.PyModulesVector_clear(self)

    def get_allocator(self) -> "std::vector< CModule * >::allocator_type":
        return _znc_core.PyModulesVector_get_allocator(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):
        _znc_core.PyModulesVector_swiginit(self, _znc_core.new_PyModulesVector(*args))

    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

# Register PyModulesVector in _znc_core:
_znc_core.PyModulesVector_swigregister(PyModulesVector)

class VListeners(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< CListener * >::value_type":
        return _znc_core.VListeners_pop(self)

    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 swap(self, v: 'VListeners') -> "void":
        return _znc_core.VListeners_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.VListeners_clear(self)

    def get_allocator(self) -> "std::vector< CListener * >::allocator_type":
        return _znc_core.VListeners_get_allocator(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):
        _znc_core.VListeners_swiginit(self, _znc_core.new_VListeners(*args))

    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

# Register VListeners in _znc_core:
_znc_core.VListeners_swigregister(VListeners)

class BufLines(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::deque< CBufLine >::value_type":
        return _znc_core.BufLines_pop(self)

    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 swap(self, v: 'BufLines') -> "void":
        return _znc_core.BufLines_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.BufLines_clear(self)

    def get_allocator(self) -> "std::deque< CBufLine >::allocator_type":
        return _znc_core.BufLines_get_allocator(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):
        _znc_core.BufLines_swiginit(self, _znc_core.new_BufLines(*args))

    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

# Register BufLines in _znc_core:
_znc_core.BufLines_swigregister(BufLines)

class VVString(collections.abc.MutableSequence):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::value_type":
        return _znc_core.VVString_pop(self)

    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 swap(self, v: 'VVString') -> "void":
        return _znc_core.VVString_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.VVString_clear(self)

    def get_allocator(self) -> "std::vector< std::vector< CString,std::allocator< CString > > >::allocator_type":
        return _znc_core.VVString_get_allocator(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):
        _znc_core.VVString_swiginit(self, _znc_core.new_VVString(*args))

    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

# Register VVString in _znc_core:
_znc_core.VVString_swigregister(VVString)

class VClients(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< CClient * >::value_type":
        return _znc_core.VClients_pop(self)

    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 swap(self, v: 'VClients') -> "void":
        return _znc_core.VClients_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.VClients_clear(self)

    def get_allocator(self) -> "std::vector< CClient * >::allocator_type":
        return _znc_core.VClients_get_allocator(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):
        _znc_core.VClients_swiginit(self, _znc_core.new_VClients(*args))

    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

# Register VClients in _znc_core:
_znc_core.VClients_swigregister(VClients)

class VServers(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _znc_core.VServers_swiginit(self, _znc_core.new_VServers(*args))

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

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

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

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

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

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

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

    def capacity(self) -> "std::vector< CServer * >::size_type":
        return _znc_core.VServers_capacity(self)
    __swig_destroy__ = _znc_core.delete_VServers

# Register VServers in _znc_core:
_znc_core.VServers_swigregister(VServers)

class VQueries(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _znc_core.VQueries_swiginit(self, _znc_core.new_VQueries(*args))

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

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

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

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

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

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

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

    def capacity(self) -> "std::vector< CQuery * >::size_type":
        return _znc_core.VQueries_capacity(self)
    __swig_destroy__ = _znc_core.delete_VQueries

# Register VQueries in _znc_core:
_znc_core.VQueries_swigregister(VQueries)

class CTranslationInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    @staticmethod
    def GetTranslations() -> "std::map< CString,CTranslationInfo,std::less< CString >,std::allocator< std::pair< CString const,CTranslationInfo > > >":
        return _znc_core.CTranslationInfo_GetTranslations()
    sSelfName = property(_znc_core.CTranslationInfo_sSelfName_get, _znc_core.CTranslationInfo_sSelfName_set)

    def __init__(self):
        _znc_core.CTranslationInfo_swiginit(self, _znc_core.new_CTranslationInfo())
    __swig_destroy__ = _znc_core.delete_CTranslationInfo

# Register CTranslationInfo in _znc_core:
_znc_core.CTranslationInfo_swigregister(CTranslationInfo)

def CTranslationInfo_GetTranslations() -> "std::map< CString,CTranslationInfo,std::less< CString >,std::allocator< std::pair< CString const,CTranslationInfo > > >":
    return _znc_core.CTranslationInfo_GetTranslations()

class CTranslation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    @staticmethod
    def Get() -> "CTranslation &":
        return _znc_core.CTranslation_Get()

    def Singular(self, sDomain: 'CString const &', sContext: 'CString const &', sEnglish: 'CString const &') -> "CString":
        return _znc_core.CTranslation_Singular(self, sDomain, sContext, sEnglish)

    def Plural(self, sDomain: 'CString const &', sContext: 'CString const &', sEnglish: 'CString const &', sEnglishes: 'CString const &', iNum: 'int') -> "CString":
        return _znc_core.CTranslation_Plural(self, sDomain, sContext, sEnglish, sEnglishes, iNum)

    def PushLanguage(self, sLanguage: 'CString const &') -> "void":
        return _znc_core.CTranslation_PushLanguage(self, sLanguage)

    def PopLanguage(self) -> "void":
        return _znc_core.CTranslation_PopLanguage(self)

    def NewReference(self, sDomain: 'CString const &') -> "void":
        return _znc_core.CTranslation_NewReference(self, sDomain)

    def DelReference(self, sDomain: 'CString const &') -> "void":
        return _znc_core.CTranslation_DelReference(self, sDomain)

    def __init__(self):
        _znc_core.CTranslation_swiginit(self, _znc_core.new_CTranslation())
    __swig_destroy__ = _znc_core.delete_CTranslation

# Register CTranslation in _znc_core:
_znc_core.CTranslation_swigregister(CTranslation)

def CTranslation_Get() -> "CTranslation &":
    return _znc_core.CTranslation_Get()

class CLanguageScope(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sLanguage: 'CString const &'):
        _znc_core.CLanguageScope_swiginit(self, _znc_core.new_CLanguageScope(sLanguage))
    __swig_destroy__ = _znc_core.delete_CLanguageScope

# Register CLanguageScope in _znc_core:
_znc_core.CLanguageScope_swigregister(CLanguageScope)

class CTranslationDomainRefHolder(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sDomain: 'CString const &'):
        _znc_core.CTranslationDomainRefHolder_swiginit(self, _znc_core.new_CTranslationDomainRefHolder(sDomain))
    __swig_destroy__ = _znc_core.delete_CTranslationDomainRefHolder

# Register CTranslationDomainRefHolder in _znc_core:
_znc_core.CTranslationDomainRefHolder_swigregister(CTranslationDomainRefHolder)

class CDelayedTranslation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CDelayedTranslation_swiginit(self, _znc_core.new_CDelayedTranslation(*args))

    def Resolve(self) -> "CString":
        return _znc_core.CDelayedTranslation_Resolve(self)
    __swig_destroy__ = _znc_core.delete_CDelayedTranslation

# Register CDelayedTranslation in _znc_core:
_znc_core.CDelayedTranslation_swigregister(CDelayedTranslation)

class COptionalTranslation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.COptionalTranslation_swiginit(self, _znc_core.new_COptionalTranslation(*args))

    def Resolve(self) -> "CString":
        return _znc_core.COptionalTranslation_Resolve(self)
    __swig_destroy__ = _znc_core.delete_COptionalTranslation

# Register COptionalTranslation in _znc_core:
_znc_core.COptionalTranslation_swigregister(COptionalTranslation)

class CCoreTranslationMixin(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CCoreTranslationMixin_swiginit(self, _znc_core.new_CCoreTranslationMixin())
    __swig_destroy__ = _znc_core.delete_CCoreTranslationMixin

# Register CCoreTranslationMixin in _znc_core:
_znc_core.CCoreTranslationMixin_swigregister(CCoreTranslationMixin)


def SetFdCloseOnExec(fd: 'int') -> "void":
    return _znc_core.SetFdCloseOnExec(fd)
class CUtils(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CUtils_swiginit(self, _znc_core.new_CUtils())
    __swig_destroy__ = _znc_core.delete_CUtils

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

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

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

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

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

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

    @staticmethod
    def PrintStatus(*args) -> "void":
        return _znc_core.CUtils_PrintStatus(*args)

    @staticmethod
    def GetSaltedHashPass(sSalt: 'CString &') -> "CString":
        return _znc_core.CUtils_GetSaltedHashPass(sSalt)

    @staticmethod
    def GetSalt() -> "CString":
        return _znc_core.CUtils_GetSalt()

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

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

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

    @staticmethod
    def GetInput(*args) -> "bool":
        return _znc_core.CUtils_GetInput(*args)

    @staticmethod
    def GetBoolInput(*args) -> "bool":
        return _znc_core.CUtils_GetBoolInput(*args)

    @staticmethod
    def GetNumInput(*args) -> "bool":
        return _znc_core.CUtils_GetNumInput(*args)

    @staticmethod
    def GetTime() -> "timeval":
        return _znc_core.CUtils_GetTime()

    @staticmethod
    def GetMillTime() -> "unsigned long long":
        return _znc_core.CUtils_GetMillTime()

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

    @staticmethod
    def FormatTime(*args) -> "CString":
        return _znc_core.CUtils_FormatTime(*args)

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

    @staticmethod
    def ParseServerTime(sTime: 'CString const &') -> "timeval":
        return _znc_core.CUtils_ParseServerTime(sTime)

    @staticmethod
    def GetTimezones() -> "SCString":
        return _znc_core.CUtils_GetTimezones()

    @staticmethod
    def GetEncodings() -> "SCString":
        return _znc_core.CUtils_GetEncodings()

    @staticmethod
    def CheckCIDR(sIP: 'CString const &', sRange: 'CString const &') -> "bool":
        return _znc_core.CUtils_CheckCIDR(sIP, sRange)

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

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

# Register CUtils in _znc_core:
_znc_core.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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def CUtils_GetTime() -> "timeval":
    return _znc_core.CUtils_GetTime()

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

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

def CUtils_FormatTime(*args) -> "CString":
    return _znc_core.CUtils_FormatTime(*args)

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

def CUtils_ParseServerTime(sTime: 'CString const &') -> "timeval":
    return _znc_core.CUtils_ParseServerTime(sTime)

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

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

def CUtils_CheckCIDR(sIP: 'CString const &', sRange: 'CString const &') -> "bool":
    return _znc_core.CUtils_CheckCIDR(sIP, sRange)

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

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

class CException(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    EX_Shutdown = _znc_core.CException_EX_Shutdown
    EX_Restart = _znc_core.CException_EX_Restart

    def __init__(self, e: 'CException::EType'):
        _znc_core.CException_swiginit(self, _znc_core.new_CException(e))
    __swig_destroy__ = _znc_core.delete_CException

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

# Register CException in _znc_core:
_znc_core.CException_swigregister(CException)

class CTable(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    GridStyle = _znc_core.CTable_GridStyle
    ListStyle = _znc_core.CTable_ListStyle

    def __init__(self):
        _znc_core.CTable_swiginit(self, _znc_core.new_CTable())
    __swig_destroy__ = _znc_core.delete_CTable

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

    def SetStyle(self, eNewStyle: 'CTable::EStyle') -> "bool":
        return _znc_core.CTable_SetStyle(self, eNewStyle)

    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)

# Register CTable in _znc_core:
_znc_core.CTable_swigregister(CTable)

class CConfigEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CConfigEntry_swiginit(self, _znc_core.new_CConfigEntry(*args))
    __swig_destroy__ = _znc_core.delete_CConfigEntry
    m_pSubConfig = property(_znc_core.CConfigEntry_m_pSubConfig_get, _znc_core.CConfigEntry_m_pSubConfig_set)

# Register CConfigEntry in _znc_core:
_znc_core.CConfigEntry_swigregister(CConfigEntry)

class CConfig(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CConfig_swiginit(self, _znc_core.new_CConfig())

    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)
    __swig_destroy__ = _znc_core.delete_CConfig

# Register CConfig in _znc_core:
_znc_core.CConfig_swigregister(CConfig)

CS_INVALID_SOCK = _znc_core.CS_INVALID_SOCK
class CSCharBuffer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, iSize: 'size_t'):
        _znc_core.CSCharBuffer_swiginit(self, _znc_core.new_CSCharBuffer(iSize))
    __swig_destroy__ = _znc_core.delete_CSCharBuffer

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

# Register CSCharBuffer in _znc_core:
_znc_core.CSCharBuffer_swigregister(CSCharBuffer)

class CSSockAddr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CSSockAddr_swiginit(self, _znc_core.new_CSSockAddr())
    __swig_destroy__ = _znc_core.delete_CSSockAddr
    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)

# Register CSSockAddr in _znc_core:
_znc_core.CSSockAddr_swigregister(CSSockAddr)

class CGetAddrInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sHostname: 'CString const &', pSock: 'Csock', csSockAddr: 'CSSockAddr'):
        _znc_core.CGetAddrInfo_swiginit(self, _znc_core.new_CGetAddrInfo(sHostname, pSock, csSockAddr))
    __swig_destroy__ = _znc_core.delete_CGetAddrInfo

    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)

# Register CGetAddrInfo in _znc_core:
_znc_core.CGetAddrInfo_swigregister(CGetAddrInfo)


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

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

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

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

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

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

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

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

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

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

def millitime() -> "uint64_t":
    return _znc_core.millitime()
class CCron(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CCron_swiginit(self, _znc_core.new_CCron())
    __swig_destroy__ = _znc_core.delete_CCron

    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)

# Register CCron in _znc_core:
_znc_core.CCron_swigregister(CCron)
CS_BLOCKSIZE = cvar.CS_BLOCKSIZE

class CSMonitorFD(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CSMonitorFD_swiginit(self, _znc_core.new_CSMonitorFD())
    __swig_destroy__ = _znc_core.delete_CSMonitorFD

    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)

# Register CSMonitorFD in _znc_core:
_znc_core.CSMonitorFD_swigregister(CSMonitorFD)

class CSockCommon(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CSockCommon_swiginit(self, _znc_core.new_CSockCommon())
    __swig_destroy__ = _znc_core.delete_CSockCommon

    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)

# Register CSockCommon in _znc_core:
_znc_core.CSockCommon_swigregister(CSockCommon)

class Csock(CSockCommon):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.Csock_swiginit(self, _znc_core.new_Csock(*args))

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

    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
    TLS = _znc_core.Csock_TLS
    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 ConnectUnix(self, sPath: 'CString const &') -> "bool":
        return _znc_core.Csock_ConnectUnix(self, sPath)

    def ListenUnix(self, *args) -> "bool":
        return _znc_core.Csock_ListenUnix(self, *args)

    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)

# Register Csock in _znc_core:
_znc_core.Csock_swigregister(Csock)

class CSConnection(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sHostname: 'CString const &', iPort: 'uint16_t', iTimeout: 'int'=60):
        _znc_core.CSConnection_swiginit(self, _znc_core.new_CSConnection(sHostname, iPort, iTimeout))
    __swig_destroy__ = _znc_core.delete_CSConnection

    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)

# Register CSConnection in _znc_core:
_znc_core.CSConnection_swigregister(CSConnection)

class CSSSLConnection(CSConnection):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sHostname: 'CString const &', iPort: 'uint16_t', iTimeout: 'int'=60):
        _znc_core.CSSSLConnection_swiginit(self, _znc_core.new_CSSSLConnection(sHostname, iPort, iTimeout))
    __swig_destroy__ = _znc_core.delete_CSSSLConnection

# Register CSSSLConnection in _znc_core:
_znc_core.CSSSLConnection_swigregister(CSSSLConnection)

class CSListener(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CSListener_swiginit(self, _znc_core.new_CSListener(*args))
    __swig_destroy__ = _znc_core.delete_CSListener

    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)

# Register CSListener in _znc_core:
_znc_core.CSListener_swigregister(CSListener)

class CSocketManager(CSockCommon):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CSocketManager_swiginit(self, _znc_core.new_CSocketManager())
    __swig_destroy__ = _znc_core.delete_CSocketManager

    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)

# Register CSocketManager in _znc_core:
_znc_core.CSocketManager_swigregister(CSocketManager)

class ZNCSocketManager(CSocketManager):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.ZNCSocketManager_swiginit(self, _znc_core.new_ZNCSocketManager())
    __swig_destroy__ = _znc_core.delete_ZNCSocketManager

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

# Register ZNCSocketManager in _znc_core:
_znc_core.ZNCSocketManager_swigregister(ZNCSocketManager)

class CZNCSock(Csock):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CZNCSock_swiginit(self, _znc_core.new_CZNCSock(*args))
    __swig_destroy__ = _znc_core.delete_CZNCSock

    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 GetSSLPeerFingerprint(self) -> "CString":
        return _znc_core.CZNCSock_GetSSLPeerFingerprint(self)

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

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

    def SetTrustAllCerts(self, bTrustAll: 'bool') -> "void":
        return _znc_core.CZNCSock_SetTrustAllCerts(self, bTrustAll)

    def GetTrustAllCerts(self) -> "bool":
        return _znc_core.CZNCSock_GetTrustAllCerts(self)

    def SetTrustPKI(self, bTrustPKI: 'bool') -> "void":
        return _znc_core.CZNCSock_SetTrustPKI(self, bTrustPKI)

    def GetTrustPKI(self) -> "bool":
        return _znc_core.CZNCSock_GetTrustPKI(self)

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

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

# Register CZNCSock in _znc_core:
_znc_core.CZNCSock_swigregister(CZNCSock)

ADDR_IPV4ONLY = _znc_core.ADDR_IPV4ONLY
ADDR_IPV6ONLY = _znc_core.ADDR_IPV6ONLY
ADDR_ALL = _znc_core.ADDR_ALL
class CSockManager(ZNCSocketManager):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CSockManager_swiginit(self, _znc_core.new_CSockManager())
    __swig_destroy__ = _znc_core.delete_CSockManager

    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)

# Register CSockManager in _znc_core:
_znc_core.CSockManager_swigregister(CSockManager)

class CSocket(CZNCSock):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CSocket_swiginit(self, _znc_core.new_CSocket(*args))
    __swig_destroy__ = _znc_core.delete_CSocket

    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)

# Register CSocket in _znc_core:
_znc_core.CSocket_swigregister(CSocket)

class CIRCSocket(CZNCSock):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CIRCSocket_swiginit(self, _znc_core.new_CIRCSocket())
    __swig_destroy__ = _znc_core.delete_CIRCSocket

# Register CIRCSocket in _znc_core:
_znc_core.CIRCSocket_swigregister(CIRCSocket)

class CFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CFile_swiginit(self, _znc_core.new_CFile(*args))
    __swig_destroy__ = _znc_core.delete_CFile
    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)

    @staticmethod
    def FType(sFileName: 'CString const &', eType: 'CFile::EFileTypes', bUseLstat: 'bool'=False) -> "bool":
        return _znc_core.CFile_FType(sFileName, eType, bUseLstat)
    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

    @staticmethod
    def Exists(*args) -> "bool":
        return _znc_core.CFile_Exists(*args)

    @staticmethod
    def GetSize(*args) -> "off_t":
        return _znc_core.CFile_GetSize(*args)

    @staticmethod
    def GetATime(*args) -> "time_t":
        return _znc_core.CFile_GetATime(*args)

    @staticmethod
    def GetMTime(*args) -> "time_t":
        return _znc_core.CFile_GetMTime(*args)

    @staticmethod
    def GetCTime(*args) -> "time_t":
        return _znc_core.CFile_GetCTime(*args)

    @staticmethod
    def GetUID(*args) -> "uid_t":
        return _znc_core.CFile_GetUID(*args)

    @staticmethod
    def GetGID(*args) -> "gid_t":
        return _znc_core.CFile_GetGID(*args)

    @staticmethod
    def GetInfo(sFile: 'CString const &', st: 'stat &') -> "int":
        return _znc_core.CFile_GetInfo(sFile, st)

    @staticmethod
    def Delete(*args) -> "bool":
        return _znc_core.CFile_Delete(*args)

    @staticmethod
    def Move(*args) -> "bool":
        return _znc_core.CFile_Move(*args)

    @staticmethod
    def Copy(*args) -> "bool":
        return _znc_core.CFile_Copy(*args)

    @staticmethod
    def Chmod(*args) -> "bool":
        return _znc_core.CFile_Chmod(*args)

    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)

    @staticmethod
    def InitHomePath(sFallback: 'CString const &') -> "void":
        return _znc_core.CFile_InitHomePath(sFallback)

    @staticmethod
    def GetHomePath() -> "CString const &":
        return _znc_core.CFile_GetHomePath()

# Register CFile in _znc_core:
_znc_core.CFile_swigregister(CFile)

def CFile_FType(sFileName: 'CString const &', eType: 'CFile::EFileTypes', bUseLstat: 'bool'=False) -> "bool":
    return _znc_core.CFile_FType(sFileName, eType, bUseLstat)

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

def CFile_GetSize(*args) -> "off_t":
    return _znc_core.CFile_GetSize(*args)

def CFile_GetATime(*args) -> "time_t":
    return _znc_core.CFile_GetATime(*args)

def CFile_GetMTime(*args) -> "time_t":
    return _znc_core.CFile_GetMTime(*args)

def CFile_GetCTime(*args) -> "time_t":
    return _znc_core.CFile_GetCTime(*args)

def CFile_GetUID(*args) -> "uid_t":
    return _znc_core.CFile_GetUID(*args)

def CFile_GetGID(*args) -> "gid_t":
    return _znc_core.CFile_GetGID(*args)

def CFile_GetInfo(sFile: 'CString const &', st: 'stat &') -> "int":
    return _znc_core.CFile_GetInfo(sFile, st)

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

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

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

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

def CFile_InitHomePath(sFallback: 'CString const &') -> "void":
    return _znc_core.CFile_InitHomePath(sFallback)

def CFile_GetHomePath() -> "CString const &":
    return _znc_core.CFile_GetHomePath()

class CDir(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CDir_swiginit(self, _znc_core.new_CDir(*args))
    __swig_destroy__ = _znc_core.delete_CDir

    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)

    @staticmethod
    def CheckPathPrefix(*args) -> "CString":
        return _znc_core.CDir_CheckPathPrefix(*args)

    @staticmethod
    def ChangeDir(*args) -> "CString":
        return _znc_core.CDir_ChangeDir(*args)

    @staticmethod
    def MakeDir(sPath: 'CString const &', iMode: 'mode_t'=int('0700', 8)) -> "bool":
        return _znc_core.CDir_MakeDir(sPath, iMode)

    @staticmethod
    def GetCWD() -> "CString":
        return _znc_core.CDir_GetCWD()

# Register CDir in _znc_core:
_znc_core.CDir_swigregister(CDir)

def CDir_CheckPathPrefix(*args) -> "CString":
    return _znc_core.CDir_CheckPathPrefix(*args)

def CDir_ChangeDir(*args) -> "CString":
    return _znc_core.CDir_ChangeDir(*args)

def CDir_MakeDir(sPath: 'CString const &', iMode: 'mode_t'=int('0700', 8)) -> "bool":
    return _znc_core.CDir_MakeDir(sPath, iMode)

def CDir_GetCWD() -> "CString":
    return _znc_core.CDir_GetCWD()

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

    def __init__(self, *args):
        _znc_core.CMessage_swiginit(self, _znc_core.new_CMessage(*args))
    Type_Unknown = _znc_core.CMessage_Type_Unknown
    Type_Account = _znc_core.CMessage_Type_Account
    Type_Action = _znc_core.CMessage_Type_Action
    Type_Away = _znc_core.CMessage_Type_Away
    Type_Capability = _znc_core.CMessage_Type_Capability
    Type_CTCP = _znc_core.CMessage_Type_CTCP
    Type_Error = _znc_core.CMessage_Type_Error
    Type_Invite = _znc_core.CMessage_Type_Invite
    Type_Join = _znc_core.CMessage_Type_Join
    Type_Kick = _znc_core.CMessage_Type_Kick
    Type_Mode = _znc_core.CMessage_Type_Mode
    Type_Nick = _znc_core.CMessage_Type_Nick
    Type_Notice = _znc_core.CMessage_Type_Notice
    Type_Numeric = _znc_core.CMessage_Type_Numeric
    Type_Part = _znc_core.CMessage_Type_Part
    Type_Ping = _znc_core.CMessage_Type_Ping
    Type_Pong = _znc_core.CMessage_Type_Pong
    Type_Quit = _znc_core.CMessage_Type_Quit
    Type_Text = _znc_core.CMessage_Type_Text
    Type_Topic = _znc_core.CMessage_Type_Topic
    Type_Wallops = _znc_core.CMessage_Type_Wallops

    def GetType(self) -> "CMessage::Type":
        return _znc_core.CMessage_GetType(self)

    def Equals(self, Other: 'CMessage') -> "bool":
        return _znc_core.CMessage_Equals(self, Other)

    def Clone(self, Other: 'CMessage') -> "void":
        return _znc_core.CMessage_Clone(self, Other)

    def GetNetwork(self) -> "CIRCNetwork *":
        return _znc_core.CMessage_GetNetwork(self)

    def SetNetwork(self, pNetwork: 'CIRCNetwork') -> "void":
        return _znc_core.CMessage_SetNetwork(self, pNetwork)

    def GetClient(self) -> "CClient *":
        return _znc_core.CMessage_GetClient(self)

    def SetClient(self, pClient: 'CClient') -> "void":
        return _znc_core.CMessage_SetClient(self, pClient)

    def GetChan(self) -> "CChan *":
        return _znc_core.CMessage_GetChan(self)

    def SetChan(self, pChan: 'CChan') -> "void":
        return _znc_core.CMessage_SetChan(self, pChan)

    def GetNick(self, *args) -> "CNick const &":
        return _znc_core.CMessage_GetNick(self, *args)

    def SetNick(self, Nick: 'CNick') -> "void":
        return _znc_core.CMessage_SetNick(self, Nick)

    def GetCommand(self) -> "CString const &":
        return _znc_core.CMessage_GetCommand(self)

    def SetCommand(self, sCommand: 'CString const &') -> "void":
        return _znc_core.CMessage_SetCommand(self, sCommand)

    def GetParamsSplit(self, uIdx: 'unsigned int', uLen: 'unsigned int'=-1) -> "VCString":
        return _znc_core.CMessage_GetParamsSplit(self, uIdx, uLen)

    def SetParams(self, vsParams: 'VCString') -> "void":
        return _znc_core.CMessage_SetParams(self, vsParams)

    def GetParams(self, *args) -> "CString":
        return _znc_core.CMessage_GetParams(self, *args)

    def GetParamsColon(self, uIdx: 'unsigned int', uLen: 'unsigned int'=-1) -> "CString":
        return _znc_core.CMessage_GetParamsColon(self, uIdx, uLen)

    def GetParam(self, uIdx: 'unsigned int') -> "CString":
        return _znc_core.CMessage_GetParam(self, uIdx)

    def SetParam(self, uIdx: 'unsigned int', sParam: 'CString const &') -> "void":
        return _znc_core.CMessage_SetParam(self, uIdx, sParam)

    def GetTime(self) -> "timeval const &":
        return _znc_core.CMessage_GetTime(self)

    def SetTime(self, ts: 'timeval const &') -> "void":
        return _znc_core.CMessage_SetTime(self, ts)

    def GetTags(self) -> "MCString const &":
        return _znc_core.CMessage_GetTags(self)

    def SetTags(self, mssTags: 'MCString') -> "void":
        return _znc_core.CMessage_SetTags(self, mssTags)

    def GetTag(self, sKey: 'CString const &') -> "CString":
        return _znc_core.CMessage_GetTag(self, sKey)

    def SetTag(self, sKey: 'CString const &', sValue: 'CString const &') -> "void":
        return _znc_core.CMessage_SetTag(self, sKey, sValue)
    IncludeAll = _znc_core.CMessage_IncludeAll
    ExcludePrefix = _znc_core.CMessage_ExcludePrefix
    ExcludeTags = _znc_core.CMessage_ExcludeTags

    def ToString(self, *args) -> "CString":
        return _znc_core.CMessage_ToString(self, *args)

    def Parse(self, sMessage: 'CString') -> "void":
        return _znc_core.CMessage_Parse(self, sMessage)

    def As_CTargetMessage(self) -> "CTargetMessage &":
        return _znc_core.CMessage_As_CTargetMessage(self)

    def As_CActionMessage(self) -> "CActionMessage &":
        return _znc_core.CMessage_As_CActionMessage(self)

    def As_CCTCPMessage(self) -> "CCTCPMessage &":
        return _znc_core.CMessage_As_CCTCPMessage(self)

    def As_CJoinMessage(self) -> "CJoinMessage &":
        return _znc_core.CMessage_As_CJoinMessage(self)

    def As_CModeMessage(self) -> "CModeMessage &":
        return _znc_core.CMessage_As_CModeMessage(self)

    def As_CNickMessage(self) -> "CNickMessage &":
        return _znc_core.CMessage_As_CNickMessage(self)

    def As_CNoticeMessage(self) -> "CNoticeMessage &":
        return _znc_core.CMessage_As_CNoticeMessage(self)

    def As_CNumericMessage(self) -> "CNumericMessage &":
        return _znc_core.CMessage_As_CNumericMessage(self)

    def As_CKickMessage(self) -> "CKickMessage &":
        return _znc_core.CMessage_As_CKickMessage(self)

    def As_CPartMessage(self) -> "CPartMessage &":
        return _znc_core.CMessage_As_CPartMessage(self)

    def As_CQuitMessage(self) -> "CQuitMessage &":
        return _znc_core.CMessage_As_CQuitMessage(self)

    def As_CTextMessage(self) -> "CTextMessage &":
        return _znc_core.CMessage_As_CTextMessage(self)

    def As_CTopicMessage(self) -> "CTopicMessage &":
        return _znc_core.CMessage_As_CTopicMessage(self)

    def __str__(self) -> "CString":
        return _znc_core.CMessage___str__(self)

    def __repr__(self) -> "CString":
        return _znc_core.CMessage___repr__(self)
    __swig_destroy__ = _znc_core.delete_CMessage

# Register CMessage in _znc_core:
_znc_core.CMessage_swigregister(CMessage)

class CTargetMessage(CMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetTarget(self) -> "CString":
        return _znc_core.CTargetMessage_GetTarget(self)

    def SetTarget(self, sTarget: 'CString const &') -> "void":
        return _znc_core.CTargetMessage_SetTarget(self, sTarget)

    def __init__(self):
        _znc_core.CTargetMessage_swiginit(self, _znc_core.new_CTargetMessage())
    __swig_destroy__ = _znc_core.delete_CTargetMessage

# Register CTargetMessage in _znc_core:
_znc_core.CTargetMessage_swigregister(CTargetMessage)

class CActionMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetText(self) -> "CString":
        return _znc_core.CActionMessage_GetText(self)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CActionMessage_SetText(self, sText)

    def __init__(self):
        _znc_core.CActionMessage_swiginit(self, _znc_core.new_CActionMessage())
    __swig_destroy__ = _znc_core.delete_CActionMessage

# Register CActionMessage in _znc_core:
_znc_core.CActionMessage_swigregister(CActionMessage)

class CCTCPMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def IsReply(self) -> "bool":
        return _znc_core.CCTCPMessage_IsReply(self)

    def GetText(self) -> "CString":
        return _znc_core.CCTCPMessage_GetText(self)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CCTCPMessage_SetText(self, sText)

    def __init__(self):
        _znc_core.CCTCPMessage_swiginit(self, _znc_core.new_CCTCPMessage())
    __swig_destroy__ = _znc_core.delete_CCTCPMessage

# Register CCTCPMessage in _znc_core:
_znc_core.CCTCPMessage_swigregister(CCTCPMessage)

class CJoinMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetKey(self) -> "CString":
        return _znc_core.CJoinMessage_GetKey(self)

    def SetKey(self, sKey: 'CString const &') -> "void":
        return _znc_core.CJoinMessage_SetKey(self, sKey)

    def __init__(self):
        _znc_core.CJoinMessage_swiginit(self, _znc_core.new_CJoinMessage())
    __swig_destroy__ = _znc_core.delete_CJoinMessage

# Register CJoinMessage in _znc_core:
_znc_core.CJoinMessage_swigregister(CJoinMessage)

class CModeMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetModes(self) -> "CString":
        return _znc_core.CModeMessage_GetModes(self)

    def GetModeList(self) -> "CString":
        return _znc_core.CModeMessage_GetModeList(self)

    def GetModeParams(self) -> "VCString":
        return _znc_core.CModeMessage_GetModeParams(self)

    def HasModes(self) -> "bool":
        return _znc_core.CModeMessage_HasModes(self)

    def __init__(self):
        _znc_core.CModeMessage_swiginit(self, _znc_core.new_CModeMessage())
    __swig_destroy__ = _znc_core.delete_CModeMessage

# Register CModeMessage in _znc_core:
_znc_core.CModeMessage_swigregister(CModeMessage)

class CNickMessage(CMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetOldNick(self) -> "CString":
        return _znc_core.CNickMessage_GetOldNick(self)

    def GetNewNick(self) -> "CString":
        return _znc_core.CNickMessage_GetNewNick(self)

    def SetNewNick(self, sNick: 'CString const &') -> "void":
        return _znc_core.CNickMessage_SetNewNick(self, sNick)

    def __init__(self):
        _znc_core.CNickMessage_swiginit(self, _znc_core.new_CNickMessage())
    __swig_destroy__ = _znc_core.delete_CNickMessage

# Register CNickMessage in _znc_core:
_znc_core.CNickMessage_swigregister(CNickMessage)

class CNoticeMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetText(self) -> "CString":
        return _znc_core.CNoticeMessage_GetText(self)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CNoticeMessage_SetText(self, sText)

    def __init__(self):
        _znc_core.CNoticeMessage_swiginit(self, _znc_core.new_CNoticeMessage())
    __swig_destroy__ = _znc_core.delete_CNoticeMessage

# Register CNoticeMessage in _znc_core:
_znc_core.CNoticeMessage_swigregister(CNoticeMessage)

class CNumericMessage(CMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetCode(self) -> "unsigned int":
        return _znc_core.CNumericMessage_GetCode(self)

    def __init__(self):
        _znc_core.CNumericMessage_swiginit(self, _znc_core.new_CNumericMessage())
    __swig_destroy__ = _znc_core.delete_CNumericMessage

# Register CNumericMessage in _znc_core:
_znc_core.CNumericMessage_swigregister(CNumericMessage)

class CKickMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetKickedNick(self) -> "CString":
        return _znc_core.CKickMessage_GetKickedNick(self)

    def SetKickedNick(self, sNick: 'CString const &') -> "void":
        return _znc_core.CKickMessage_SetKickedNick(self, sNick)

    def GetReason(self) -> "CString":
        return _znc_core.CKickMessage_GetReason(self)

    def SetReason(self, sReason: 'CString const &') -> "void":
        return _znc_core.CKickMessage_SetReason(self, sReason)

    def GetText(self) -> "CString":
        return _znc_core.CKickMessage_GetText(self)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CKickMessage_SetText(self, sText)

    def __init__(self):
        _znc_core.CKickMessage_swiginit(self, _znc_core.new_CKickMessage())
    __swig_destroy__ = _znc_core.delete_CKickMessage

# Register CKickMessage in _znc_core:
_znc_core.CKickMessage_swigregister(CKickMessage)

class CPartMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetReason(self) -> "CString":
        return _znc_core.CPartMessage_GetReason(self)

    def SetReason(self, sReason: 'CString const &') -> "void":
        return _znc_core.CPartMessage_SetReason(self, sReason)

    def GetText(self) -> "CString":
        return _znc_core.CPartMessage_GetText(self)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CPartMessage_SetText(self, sText)

    def __init__(self):
        _znc_core.CPartMessage_swiginit(self, _znc_core.new_CPartMessage())
    __swig_destroy__ = _znc_core.delete_CPartMessage

# Register CPartMessage in _znc_core:
_znc_core.CPartMessage_swigregister(CPartMessage)

class CQuitMessage(CMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetReason(self) -> "CString":
        return _znc_core.CQuitMessage_GetReason(self)

    def SetReason(self, sReason: 'CString const &') -> "void":
        return _znc_core.CQuitMessage_SetReason(self, sReason)

    def GetText(self) -> "CString":
        return _znc_core.CQuitMessage_GetText(self)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CQuitMessage_SetText(self, sText)

    def __init__(self):
        _znc_core.CQuitMessage_swiginit(self, _znc_core.new_CQuitMessage())
    __swig_destroy__ = _znc_core.delete_CQuitMessage

# Register CQuitMessage in _znc_core:
_znc_core.CQuitMessage_swigregister(CQuitMessage)

class CTextMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetText(self) -> "CString":
        return _znc_core.CTextMessage_GetText(self)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CTextMessage_SetText(self, sText)

    def __init__(self):
        _znc_core.CTextMessage_swiginit(self, _znc_core.new_CTextMessage())
    __swig_destroy__ = _znc_core.delete_CTextMessage

# Register CTextMessage in _znc_core:
_znc_core.CTextMessage_swigregister(CTextMessage)

class CTopicMessage(CTargetMessage):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def GetTopic(self) -> "CString":
        return _znc_core.CTopicMessage_GetTopic(self)

    def SetTopic(self, sTopic: 'CString const &') -> "void":
        return _znc_core.CTopicMessage_SetTopic(self, sTopic)

    def GetText(self) -> "CString":
        return _znc_core.CTopicMessage_GetText(self)

    def SetText(self, sText: 'CString const &') -> "void":
        return _znc_core.CTopicMessage_SetText(self, sText)

    def __init__(self):
        _znc_core.CTopicMessage_swiginit(self, _znc_core.new_CTopicMessage())
    __swig_destroy__ = _znc_core.delete_CTopicMessage

# Register CTopicMessage in _znc_core:
_znc_core.CTopicMessage_swigregister(CTopicMessage)

class CModuleEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    pcVersion = property(_znc_core.CModuleEntry_pcVersion_get, _znc_core.CModuleEntry_pcVersion_set)
    pcVersionExtra = property(_znc_core.CModuleEntry_pcVersionExtra_get, _znc_core.CModuleEntry_pcVersionExtra_set)
    pcCompileOptions = property(_znc_core.CModuleEntry_pcCompileOptions_get, _znc_core.CModuleEntry_pcCompileOptions_set)
    fpFillModInfo = property(_znc_core.CModuleEntry_fpFillModInfo_get, _znc_core.CModuleEntry_fpFillModInfo_set)

    def __init__(self):
        _znc_core.CModuleEntry_swiginit(self, _znc_core.new_CModuleEntry())
    __swig_destroy__ = _znc_core.delete_CModuleEntry

# Register CModuleEntry in _znc_core:
_znc_core.CModuleEntry_swigregister(CModuleEntry)

class CTimer(CCron):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pModule: 'CModule', uInterval: 'unsigned int', uCycles: 'unsigned int', sLabel: 'CString const &', sDescription: 'CString const &'):
        _znc_core.CTimer_swiginit(self, _znc_core.new_CTimer(pModule, uInterval, uCycles, sLabel, sDescription))
    __swig_destroy__ = _znc_core.delete_CTimer

    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)

# Register CTimer in _znc_core:
_znc_core.CTimer_swigregister(CTimer)

class CFPTimer(CTimer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pModule: 'CModule', uInterval: 'unsigned int', uCycles: 'unsigned int', sLabel: 'CString const &', sDescription: 'CString const &'):
        _znc_core.CFPTimer_swiginit(self, _znc_core.new_CFPTimer(pModule, uInterval, uCycles, sLabel, sDescription))
    __swig_destroy__ = _znc_core.delete_CFPTimer

    def SetFPCallback(self, p: 'FPTimer_t') -> "void":
        return _znc_core.CFPTimer_SetFPCallback(self, p)

# Register CFPTimer in _znc_core:
_znc_core.CFPTimer_swigregister(CFPTimer)

class CModInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    GlobalModule = _znc_core.CModInfo_GlobalModule
    UserModule = _znc_core.CModInfo_UserModule
    NetworkModule = _znc_core.CModInfo_NetworkModule

    def __init__(self, *args):
        _znc_core.CModInfo_swiginit(self, _znc_core.new_CModInfo(*args))
    __swig_destroy__ = _znc_core.delete_CModInfo

    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)

    @staticmethod
    def ModuleTypeToString(eType: 'CModInfo::EModuleType') -> "CString":
        return _znc_core.CModInfo_ModuleTypeToString(eType)

    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)

    def t_s(self, *args) -> "CString":
        return _znc_core.CModInfo_t_s(self, *args)

# Register CModInfo in _znc_core:
_znc_core.CModInfo_swigregister(CModInfo)

def CModInfo_ModuleTypeToString(eType: 'CModInfo::EModuleType') -> "CString":
    return _znc_core.CModInfo_ModuleTypeToString(eType)

class CModCommand(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CModCommand_swiginit(self, _znc_core.new_CModCommand(*args))

    @staticmethod
    def InitHelp(Table: 'CTable') -> "void":
        return _znc_core.CModCommand_InitHelp(Table)

    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":
        return _znc_core.CModCommand_GetArgs(self)

    def GetDescription(self) -> "CString":
        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

# Register CModCommand in _znc_core:
_znc_core.CModCommand_swigregister(CModCommand)

def CModCommand_InitHelp(Table: 'CTable') -> "void":
    return _znc_core.CModCommand_InitHelp(Table)

class CModule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CModule_swiginit(self, _znc_core.new_CModule(*args))
    __swig_destroy__ = _znc_core.delete_CModule
    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 ValidateWebRequestCSRFCheck(self, WebSock: 'CWebSock', sPageName: 'CString const &') -> "bool":
        return _znc_core.CModule_ValidateWebRequestCSRFCheck(self, WebSock, sPageName)

    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 OnChanPermission3(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', cMode: 'char', bAdded: 'bool', bNoChange: 'bool') -> "void":
        return _znc_core.CModule_OnChanPermission3(self, pOpNick, Nick, Channel, cMode, bAdded, bNoChange)

    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 OnRawMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnRawMessage(self, Message)

    def OnNumericMessage(self, Message: 'CNumericMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnNumericMessage(self, Message)

    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 OnQuitMessage(self, Message: 'CQuitMessage', vChans: 'VChannels') -> "void":
        return _znc_core.CModule_OnQuitMessage(self, Message, vChans)

    def OnQuit(self, Nick: 'CNick', sMessage: 'CString const &', vChans: 'VChannels') -> "void":
        return _znc_core.CModule_OnQuit(self, Nick, sMessage, vChans)

    def OnNickMessage(self, Message: 'CNickMessage', vChans: 'VChannels') -> "void":
        return _znc_core.CModule_OnNickMessage(self, Message, vChans)

    def OnNick(self, Nick: 'CNick', sNewNick: 'CString const &', vChans: 'VChannels') -> "void":
        return _znc_core.CModule_OnNick(self, Nick, sNewNick, vChans)

    def OnKickMessage(self, Message: 'CKickMessage') -> "void":
        return _znc_core.CModule_OnKickMessage(self, Message)

    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 OnJoinMessage(self, Message: 'CJoinMessage') -> "void":
        return _znc_core.CModule_OnJoinMessage(self, Message)

    def OnJoin(self, Nick: 'CNick', Channel: 'CChan') -> "void":
        return _znc_core.CModule_OnJoin(self, Nick, Channel)

    def OnPartMessage(self, Message: 'CPartMessage') -> "void":
        return _znc_core.CModule_OnPartMessage(self, Message)

    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 OnChanBufferPlayMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanBufferPlayMessage(self, Message)

    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 OnPrivBufferStarting(self, Query: 'CQuery', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivBufferStarting(self, Query, Client)

    def OnPrivBufferEnding(self, Query: 'CQuery', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivBufferEnding(self, Query, Client)

    def OnPrivBufferPlayMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivBufferPlayMessage(self, Message)

    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 OnUserRawMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserRawMessage(self, Message)

    def OnUserCTCPReplyMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserCTCPReplyMessage(self, Message)

    def OnUserCTCPReply(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserCTCPReply(self, sTarget, sMessage)

    def OnUserCTCPMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserCTCPMessage(self, Message)

    def OnUserCTCP(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserCTCP(self, sTarget, sMessage)

    def OnUserActionMessage(self, Message: 'CActionMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserActionMessage(self, Message)

    def OnUserAction(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserAction(self, sTarget, sMessage)

    def OnUserTextMessage(self, Message: 'CTextMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserTextMessage(self, Message)

    def OnUserMsg(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserMsg(self, sTarget, sMessage)

    def OnUserNoticeMessage(self, Message: 'CNoticeMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserNoticeMessage(self, Message)

    def OnUserNotice(self, sTarget: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserNotice(self, sTarget, sMessage)

    def OnUserJoinMessage(self, Message: 'CJoinMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserJoinMessage(self, Message)

    def OnUserJoin(self, sChannel: 'CString &', sKey: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserJoin(self, sChannel, sKey)

    def OnUserPartMessage(self, Message: 'CPartMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserPartMessage(self, Message)

    def OnUserPart(self, sChannel: 'CString &', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserPart(self, sChannel, sMessage)

    def OnUserTopicMessage(self, Message: 'CTopicMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserTopicMessage(self, Message)

    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 OnUserQuitMessage(self, Message: 'CQuitMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserQuitMessage(self, Message)

    def OnUserQuit(self, sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnUserQuit(self, sMessage)

    def OnCTCPReplyMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnCTCPReplyMessage(self, Message)

    def OnCTCPReply(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnCTCPReply(self, Nick, sMessage)

    def OnPrivCTCPMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivCTCPMessage(self, Message)

    def OnPrivCTCP(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivCTCP(self, Nick, sMessage)

    def OnChanCTCPMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanCTCPMessage(self, Message)

    def OnChanCTCP(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanCTCP(self, Nick, Channel, sMessage)

    def OnPrivActionMessage(self, Message: 'CActionMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivActionMessage(self, Message)

    def OnPrivAction(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivAction(self, Nick, sMessage)

    def OnChanActionMessage(self, Message: 'CActionMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanActionMessage(self, Message)

    def OnChanAction(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanAction(self, Nick, Channel, sMessage)

    def OnPrivTextMessage(self, Message: 'CTextMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivTextMessage(self, Message)

    def OnPrivMsg(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivMsg(self, Nick, sMessage)

    def OnChanTextMessage(self, Message: 'CTextMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanTextMessage(self, Message)

    def OnChanMsg(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanMsg(self, Nick, Channel, sMessage)

    def OnPrivNoticeMessage(self, Message: 'CNoticeMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivNoticeMessage(self, Message)

    def OnPrivNotice(self, Nick: 'CNick', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnPrivNotice(self, Nick, sMessage)

    def OnChanNoticeMessage(self, Message: 'CNoticeMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanNoticeMessage(self, Message)

    def OnChanNotice(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnChanNotice(self, Nick, Channel, sMessage)

    def OnTopicMessage(self, Message: 'CTopicMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnTopicMessage(self, Message)

    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 OnSendToClientMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnSendToClientMessage(self, Message)

    def OnSendToClient(self, sLine: 'CString &', Client: 'CClient') -> "CModule::EModRet":
        return _znc_core.CModule_OnSendToClient(self, sLine, Client)

    def OnSendToIRCMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnSendToIRCMessage(self, Message)

    def OnSendToIRC(self, sLine: 'CString &') -> "CModule::EModRet":
        return _znc_core.CModule_OnSendToIRC(self, sLine)

    def GetDLL(self) -> "ModHandle":
        return _znc_core.CModule_GetDLL(self)

    def PutIRC(self, *args) -> "bool":
        return _znc_core.CModule_PutIRC(self, *args)

    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 HasNV(self, sName: 'CString const &') -> "bool":
        return _znc_core.CModule_HasNV(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 OnUnknownUserRawMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CModule_OnUnknownUserRawMessage(self, Message)

    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)

# Register CModule in _znc_core:
_znc_core.CModule_swigregister(CModule)

class CModules(PyModulesVector):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _znc_core.delete_CModules

    def __init__(self, *args):
        _znc_core.CModules_swiginit(self, _znc_core.new_CModules(*args))

    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 OnChanPermission3(self, pOpNick: 'CNick', Nick: 'CNick', Channel: 'CChan', cMode: 'char', bAdded: 'bool', bNoChange: 'bool') -> "bool":
        return _znc_core.CModules_OnChanPermission3(self, pOpNick, Nick, Channel, cMode, bAdded, bNoChange)

    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 OnRawMessage(self, Message: 'CMessage') -> "bool":
        return _znc_core.CModules_OnRawMessage(self, Message)

    def OnNumericMessage(self, Message: 'CNumericMessage') -> "bool":
        return _znc_core.CModules_OnNumericMessage(self, Message)

    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 OnQuitMessage(self, Message: 'CQuitMessage', vChans: 'VChannels') -> "bool":
        return _znc_core.CModules_OnQuitMessage(self, Message, vChans)

    def OnNick(self, Nick: 'CNick', sNewNick: 'CString const &', vChans: 'VChannels') -> "bool":
        return _znc_core.CModules_OnNick(self, Nick, sNewNick, vChans)

    def OnNickMessage(self, Message: 'CNickMessage', vChans: 'VChannels') -> "bool":
        return _znc_core.CModules_OnNickMessage(self, Message, 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 OnKickMessage(self, Message: 'CKickMessage') -> "bool":
        return _znc_core.CModules_OnKickMessage(self, Message)

    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 OnJoinMessage(self, Message: 'CJoinMessage') -> "bool":
        return _znc_core.CModules_OnJoinMessage(self, Message)

    def OnPart(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString const &') -> "bool":
        return _znc_core.CModules_OnPart(self, Nick, Channel, sMessage)

    def OnPartMessage(self, Message: 'CPartMessage') -> "bool":
        return _znc_core.CModules_OnPartMessage(self, Message)

    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 OnPrivBufferStarting(self, Query: 'CQuery', Client: 'CClient') -> "bool":
        return _znc_core.CModules_OnPrivBufferStarting(self, Query, Client)

    def OnPrivBufferEnding(self, Query: 'CQuery', Client: 'CClient') -> "bool":
        return _znc_core.CModules_OnPrivBufferEnding(self, Query, Client)

    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 OnChanBufferPlayMessage(self, Message: 'CMessage') -> "bool":
        return _znc_core.CModules_OnChanBufferPlayMessage(self, Message)

    def OnPrivBufferPlayMessage(self, Message: 'CMessage') -> "bool":
        return _znc_core.CModules_OnPrivBufferPlayMessage(self, Message)

    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 OnUserRawMessage(self, Message: 'CMessage') -> "bool":
        return _znc_core.CModules_OnUserRawMessage(self, Message)

    def OnUserCTCPReply(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserCTCPReply(self, sTarget, sMessage)

    def OnUserCTCPReplyMessage(self, Message: 'CCTCPMessage') -> "bool":
        return _znc_core.CModules_OnUserCTCPReplyMessage(self, Message)

    def OnUserCTCP(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserCTCP(self, sTarget, sMessage)

    def OnUserCTCPMessage(self, Message: 'CCTCPMessage') -> "bool":
        return _znc_core.CModules_OnUserCTCPMessage(self, Message)

    def OnUserAction(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserAction(self, sTarget, sMessage)

    def OnUserActionMessage(self, Message: 'CActionMessage') -> "bool":
        return _znc_core.CModules_OnUserActionMessage(self, Message)

    def OnUserMsg(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserMsg(self, sTarget, sMessage)

    def OnUserTextMessage(self, Message: 'CTextMessage') -> "bool":
        return _znc_core.CModules_OnUserTextMessage(self, Message)

    def OnUserNotice(self, sTarget: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserNotice(self, sTarget, sMessage)

    def OnUserNoticeMessage(self, Message: 'CNoticeMessage') -> "bool":
        return _znc_core.CModules_OnUserNoticeMessage(self, Message)

    def OnUserJoin(self, sChannel: 'CString &', sKey: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserJoin(self, sChannel, sKey)

    def OnUserJoinMessage(self, Message: 'CJoinMessage') -> "bool":
        return _znc_core.CModules_OnUserJoinMessage(self, Message)

    def OnUserPart(self, sChannel: 'CString &', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserPart(self, sChannel, sMessage)

    def OnUserPartMessage(self, Message: 'CPartMessage') -> "bool":
        return _znc_core.CModules_OnUserPartMessage(self, Message)

    def OnUserTopic(self, sChannel: 'CString &', sTopic: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserTopic(self, sChannel, sTopic)

    def OnUserTopicMessage(self, Message: 'CTopicMessage') -> "bool":
        return _znc_core.CModules_OnUserTopicMessage(self, Message)

    def OnUserTopicRequest(self, sChannel: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserTopicRequest(self, sChannel)

    def OnUserQuit(self, sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnUserQuit(self, sMessage)

    def OnUserQuitMessage(self, Message: 'CQuitMessage') -> "bool":
        return _znc_core.CModules_OnUserQuitMessage(self, Message)

    def OnCTCPReply(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnCTCPReply(self, Nick, sMessage)

    def OnCTCPReplyMessage(self, Message: 'CCTCPMessage') -> "bool":
        return _znc_core.CModules_OnCTCPReplyMessage(self, Message)

    def OnPrivCTCP(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivCTCP(self, Nick, sMessage)

    def OnPrivCTCPMessage(self, Message: 'CCTCPMessage') -> "bool":
        return _znc_core.CModules_OnPrivCTCPMessage(self, Message)

    def OnChanCTCP(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanCTCP(self, Nick, Channel, sMessage)

    def OnChanCTCPMessage(self, Message: 'CCTCPMessage') -> "bool":
        return _znc_core.CModules_OnChanCTCPMessage(self, Message)

    def OnPrivAction(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivAction(self, Nick, sMessage)

    def OnPrivActionMessage(self, Message: 'CActionMessage') -> "bool":
        return _znc_core.CModules_OnPrivActionMessage(self, Message)

    def OnChanAction(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanAction(self, Nick, Channel, sMessage)

    def OnChanActionMessage(self, Message: 'CActionMessage') -> "bool":
        return _znc_core.CModules_OnChanActionMessage(self, Message)

    def OnPrivMsg(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivMsg(self, Nick, sMessage)

    def OnPrivTextMessage(self, Message: 'CTextMessage') -> "bool":
        return _znc_core.CModules_OnPrivTextMessage(self, Message)

    def OnChanMsg(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanMsg(self, Nick, Channel, sMessage)

    def OnChanTextMessage(self, Message: 'CTextMessage') -> "bool":
        return _znc_core.CModules_OnChanTextMessage(self, Message)

    def OnPrivNotice(self, Nick: 'CNick', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnPrivNotice(self, Nick, sMessage)

    def OnPrivNoticeMessage(self, Message: 'CNoticeMessage') -> "bool":
        return _znc_core.CModules_OnPrivNoticeMessage(self, Message)

    def OnChanNotice(self, Nick: 'CNick', Channel: 'CChan', sMessage: 'CString &') -> "bool":
        return _znc_core.CModules_OnChanNotice(self, Nick, Channel, sMessage)

    def OnChanNoticeMessage(self, Message: 'CNoticeMessage') -> "bool":
        return _znc_core.CModules_OnChanNoticeMessage(self, Message)

    def OnTopic(self, Nick: 'CNick', Channel: 'CChan', sTopic: 'CString &') -> "bool":
        return _znc_core.CModules_OnTopic(self, Nick, Channel, sTopic)

    def OnTopicMessage(self, Message: 'CTopicMessage') -> "bool":
        return _znc_core.CModules_OnTopicMessage(self, Message)

    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 OnSendToClientMessage(self, Message: 'CMessage') -> "bool":
        return _znc_core.CModules_OnSendToClientMessage(self, Message)

    def OnSendToIRC(self, sLine: 'CString &') -> "bool":
        return _znc_core.CModules_OnSendToIRC(self, sLine)

    def OnSendToIRCMessage(self, Message: 'CMessage') -> "bool":
        return _znc_core.CModules_OnSendToIRCMessage(self, Message)

    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)

    @staticmethod
    def GetModInfo(ModInfo: 'CModInfo', sModule: 'CString const &', sRetMsg: 'CString &') -> "bool":
        return _znc_core.CModules_GetModInfo(ModInfo, sModule, sRetMsg)

    @staticmethod
    def GetModPathInfo(ModInfo: 'CModInfo', sModule: 'CString const &', sModPath: 'CString const &', sRetMsg: 'CString &') -> "bool":
        return _znc_core.CModules_GetModPathInfo(ModInfo, sModule, sModPath, sRetMsg)

    @staticmethod
    def GetAvailableMods(*args) -> "void":
        return _znc_core.CModules_GetAvailableMods(*args)

    @staticmethod
    def GetDefaultMods(*args) -> "void":
        return _znc_core.CModules_GetDefaultMods(*args)

    @staticmethod
    def FindModPath(sModule: 'CString const &', sModPath: 'CString &', sDataPath: 'CString &') -> "bool":
        return _znc_core.CModules_FindModPath(sModule, sModPath, sDataPath)

    @staticmethod
    def GetModDirs() -> "CModules::ModDirList":
        return _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 OnUnknownUserRawMessage(self, Message: 'CMessage') -> "bool":
        return _znc_core.CModules_OnUnknownUserRawMessage(self, Message)

    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)

# Register CModules in _znc_core:
_znc_core.CModules_swigregister(CModules)

def CModules_GetModInfo(ModInfo: 'CModInfo', sModule: 'CString const &', sRetMsg: 'CString &') -> "bool":
    return _znc_core.CModules_GetModInfo(ModInfo, sModule, sRetMsg)

def CModules_GetModPathInfo(ModInfo: 'CModInfo', sModule: 'CString const &', sModPath: 'CString const &', sRetMsg: 'CString &') -> "bool":
    return _znc_core.CModules_GetModPathInfo(ModInfo, sModule, sModPath, sRetMsg)

def CModules_GetAvailableMods(*args) -> "void":
    return _znc_core.CModules_GetAvailableMods(*args)

def CModules_GetDefaultMods(*args) -> "void":
    return _znc_core.CModules_GetDefaultMods(*args)

def CModules_FindModPath(sModule: 'CString const &', sModPath: 'CString &', sDataPath: 'CString &') -> "bool":
    return _znc_core.CModules_FindModPath(sModule, sModPath, sDataPath)

def CModules_GetModDirs() -> "CModules::ModDirList":
    return _znc_core.CModules_GetModDirs()

class CNick(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __swig_destroy__ = _znc_core.delete_CNick

    def __init__(self, *args):
        _znc_core.CNick_swiginit(self, _znc_core.new_CNick(*args))

    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, cPerm: 'char') -> "bool":
        return _znc_core.CNick_AddPerm(self, cPerm)

    def RemPerm(self, cPerm: 'char') -> "bool":
        return _znc_core.CNick_RemPerm(self, cPerm)

    def GetPermStr(self) -> "CString":
        return _znc_core.CNick_GetPermStr(self)

    def GetPermChar(self) -> "char":
        return _znc_core.CNick_GetPermChar(self)

    def HasPerm(self, cPerm: 'char') -> "bool":
        return _znc_core.CNick_HasPerm(self, cPerm)

    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)

# Register CNick in _znc_core:
_znc_core.CNick_swigregister(CNick)

class CChan(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    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):
        _znc_core.CChan_swiginit(self, _znc_core.new_CChan(sName, pNetwork, bInConfig, pConfig))
    __swig_destroy__ = _znc_core.delete_CChan

    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, *args) -> "void":
        return _znc_core.CChan_SetModes(self, *args)

    def ModeChange(self, *args) -> "void":
        return _znc_core.CChan_ModeChange(self, *args)

    def AddMode(self, cMode: 'char', sArg: 'CString const &') -> "bool":
        return _znc_core.CChan_AddMode(self, cMode, sArg)

    def RemMode(self, cMode: 'char') -> "bool":
        return _znc_core.CChan_RemMode(self, cMode)

    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 ResetBufferCount(self) -> "void":
        return _znc_core.CChan_ResetBufferCount(self)

    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, cPerm: 'char') -> "bool":
        return _znc_core.CChan_HasPerm(self, cPerm)

    def AddPerm(self, cPerm: 'char') -> "bool":
        return _znc_core.CChan_AddPerm(self, cPerm)

    def RemPerm(self, cPerm: 'char') -> "bool":
        return _znc_core.CChan_RemPerm(self, cPerm)

    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 ResetAutoClearChanBuffer(self) -> "void":
        return _znc_core.CChan_ResetAutoClearChanBuffer(self)

    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 GetNetwork(self) -> "CIRCNetwork *":
        return _znc_core.CChan_GetNetwork(self)

    def IsModeKnown(self) -> "bool":
        return _znc_core.CChan_IsModeKnown(self)

    def HasMode(self, cMode: 'char') -> "bool":
        return _znc_core.CChan_HasMode(self, cMode)

    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< char,CString,std::less< char >,std::allocator< std::pair< 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)

# Register CChan in _znc_core:
_znc_core.CChan_swigregister(CChan)

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

    def __init__(self, sUsername: 'CString const &'):
        _znc_core.CUser_swiginit(self, _znc_core.new_CUser(sUsername))
    __swig_destroy__ = _znc_core.delete_CUser

    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

    @staticmethod
    def SaltedHash(sPass: 'CString const &', sSalt: 'CString const &') -> "CString":
        return _znc_core.CUser_SaltedHash(sPass, sSalt)

    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 RemAllowedHost(self, sHostMask: 'CString const &') -> "bool":
        return _znc_core.CUser_RemAllowedHost(self, sHostMask)

    def ClearAllowedHosts(self) -> "void":
        return _znc_core.CUser_ClearAllowedHosts(self)

    def IsHostAllowed(self, sHost: 'CString const &') -> "bool":
        return _znc_core.CUser_IsHostAllowed(self, sHost)

    def IsValid(self, sErrMsg: 'CString &', bSkipPass: 'bool'=False) -> "bool":
        return _znc_core.CUser_IsValid(self, sErrMsg, bSkipPass)

    @staticmethod
    def IsValidUsername(sUsername: 'CString const &') -> "bool":
        return _znc_core.CUser_IsValidUsername(sUsername)

    @staticmethod
    def IsValidUserName(sUsername: 'CString const &') -> "bool":
        return _znc_core.CUser_IsValidUserName(sUsername)

    @staticmethod
    def MakeCleanUsername(sUsername: 'CString const &') -> "CString":
        return _znc_core.CUser_MakeCleanUsername(sUsername)

    @staticmethod
    def MakeCleanUserName(sUsername: 'CString const &') -> "CString":
        return _znc_core.CUser_MakeCleanUserName(sUsername)

    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 SetChanBufferSize(self, u: 'unsigned int', bForce: 'bool'=False) -> "bool":
        return _znc_core.CUser_SetChanBufferSize(self, u, bForce)

    def SetQueryBufferSize(self, u: 'unsigned int', bForce: 'bool'=False) -> "bool":
        return _znc_core.CUser_SetQueryBufferSize(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 SetLanguage(self, s: 'CString const &') -> "bool":
        return _znc_core.CUser_SetLanguage(self, s)

    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 SetAuthOnlyViaModule(self, b: 'bool') -> "void":
        return _znc_core.CUser_SetAuthOnlyViaModule(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 SetNoTrafficTimeout(self, i: 'unsigned int') -> "void":
        return _znc_core.CUser_SetNoTrafficTimeout(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 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":
        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 AuthOnlyViaModule(self) -> "bool":
        return _znc_core.CUser_AuthOnlyViaModule(self)

    def GetStatusPrefix(self) -> "CString const &":
        return _znc_core.CUser_GetStatusPrefix(self)

    def GetDefaultChanModes(self) -> "CString const &":
        return _znc_core.CUser_GetDefaultChanModes(self)

    def GetPingFrequency(self) -> "unsigned int":
        return _znc_core.CUser_GetPingFrequency(self)

    def GetPingSlack(self) -> "unsigned int":
        return _znc_core.CUser_GetPingSlack(self)

    def GetNoTrafficTimeout(self) -> "unsigned int":
        return _znc_core.CUser_GetNoTrafficTimeout(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 GetChanBufferSize(self) -> "unsigned int":
        return _znc_core.CUser_GetChanBufferSize(self)

    def GetQueryBufferSize(self) -> "unsigned int":
        return _znc_core.CUser_GetQueryBufferSize(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 GetLanguage(self) -> "CString":
        return _znc_core.CUser_GetLanguage(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)

# Register CUser in _znc_core:
_znc_core.CUser_swigregister(CUser)

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

def CUser_IsValidUsername(sUsername: 'CString const &') -> "bool":
    return _znc_core.CUser_IsValidUsername(sUsername)

def CUser_IsValidUserName(sUsername: 'CString const &') -> "bool":
    return _znc_core.CUser_IsValidUserName(sUsername)

def CUser_MakeCleanUsername(sUsername: 'CString const &') -> "CString":
    return _znc_core.CUser_MakeCleanUsername(sUsername)

def CUser_MakeCleanUserName(sUsername: 'CString const &') -> "CString":
    return _znc_core.CUser_MakeCleanUserName(sUsername)

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

    @staticmethod
    def IsValidNetwork(sNetwork: 'CString const &') -> "bool":
        return _znc_core.CIRCNetwork_IsValidNetwork(sNetwork)

    def __init__(self, *args):
        _znc_core.CIRCNetwork_swiginit(self, _znc_core.new_CIRCNetwork(*args))
    __swig_destroy__ = _znc_core.delete_CIRCNetwork

    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, *args) -> "bool":
        return _znc_core.CIRCNetwork_PutUser(self, *args)

    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, bAdvance: 'bool'=True) -> "CServer *":
        return _znc_core.CIRCNetwork_GetNextServer(self, bAdvance)

    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 ClearTrustedFingerprints(self) -> "void":
        return _znc_core.CIRCNetwork_ClearTrustedFingerprints(self)

    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, *args) -> "bool":
        return _znc_core.CIRCNetwork_PutIRC(self, *args)

    def ClearRawBuffer(self) -> "void":
        return _znc_core.CIRCNetwork_ClearRawBuffer(self)

    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 ClearMotdBuffer(self) -> "void":
        return _znc_core.CIRCNetwork_ClearMotdBuffer(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 ClearNoticeBuffer(self) -> "void":
        return _znc_core.CIRCNetwork_ClearNoticeBuffer(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 ClearQueryBuffer(self) -> "void":
        return _znc_core.CIRCNetwork_ClearQueryBuffer(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":
        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 SetTrustAllCerts(self, bTrustAll: 'bool const'=False) -> "void":
        return _znc_core.CIRCNetwork_SetTrustAllCerts(self, bTrustAll)

    def GetTrustAllCerts(self) -> "bool":
        return _znc_core.CIRCNetwork_GetTrustAllCerts(self)

    def SetTrustPKI(self, bTrustPKI: 'bool const'=True) -> "void":
        return _znc_core.CIRCNetwork_SetTrustPKI(self, bTrustPKI)

    def GetTrustPKI(self) -> "bool":
        return _znc_core.CIRCNetwork_GetTrustPKI(self)

    def BytesRead(self) -> "unsigned long long":
        return _znc_core.CIRCNetwork_BytesRead(self)

    def BytesWritten(self) -> "unsigned long long":
        return _znc_core.CIRCNetwork_BytesWritten(self)

    def AddBytesRead(self, u: 'unsigned long long') -> "void":
        return _znc_core.CIRCNetwork_AddBytesRead(self, u)

    def AddBytesWritten(self, u: 'unsigned long long') -> "void":
        return _znc_core.CIRCNetwork_AddBytesWritten(self, u)

    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)

    def GetServers_(self) -> "std::vector< CServer *,std::allocator< CServer * > >":
        return _znc_core.CIRCNetwork_GetServers_(self)

    def GetQueries_(self) -> "std::vector< CQuery *,std::allocator< CQuery * > >":
        return _znc_core.CIRCNetwork_GetQueries_(self)

# Register CIRCNetwork in _znc_core:
_znc_core.CIRCNetwork_swigregister(CIRCNetwork)

def CIRCNetwork_IsValidNetwork(sNetwork: 'CString const &') -> "bool":
    return _znc_core.CIRCNetwork_IsValidNetwork(sNetwork)

class CQuery(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sName: 'CString const &', pNetwork: 'CIRCNetwork'):
        _znc_core.CQuery_swiginit(self, _znc_core.new_CQuery(sName, pNetwork))
    __swig_destroy__ = _znc_core.delete_CQuery

    def GetBuffer(self) -> "CBuffer const &":
        return _znc_core.CQuery_GetBuffer(self)

    def GetBufferCount(self) -> "unsigned int":
        return _znc_core.CQuery_GetBufferCount(self)

    def SetBufferCount(self, u: 'unsigned int', bForce: 'bool'=False) -> "bool":
        return _znc_core.CQuery_SetBufferCount(self, u, bForce)

    def AddBuffer(self, *args) -> "size_t":
        return _znc_core.CQuery_AddBuffer(self, *args)

    def ClearBuffer(self) -> "void":
        return _znc_core.CQuery_ClearBuffer(self)

    def SendBuffer(self, *args) -> "void":
        return _znc_core.CQuery_SendBuffer(self, *args)

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

# Register CQuery in _znc_core:
_znc_core.CQuery_swigregister(CQuery)

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

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

    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)

# Register CAuthBase in _znc_core:
_znc_core.CAuthBase_swigregister(CAuthBase)

class CClientAuth(CAuthBase):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pClient: 'CClient', sUsername: 'CString const &', sPassword: 'CString const &'):
        _znc_core.CClientAuth_swiginit(self, _znc_core.new_CClientAuth(pClient, sUsername, sPassword))
    __swig_destroy__ = _znc_core.delete_CClientAuth

    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)

# Register CClientAuth in _znc_core:
_znc_core.CClientAuth_swigregister(CClientAuth)

class CClient(CIRCSocket):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CClient_swiginit(self, _znc_core.new_CClient())
    __swig_destroy__ = _znc_core.delete_CClient

    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 HasCapNotify(self) -> "bool":
        return _znc_core.CClient_HasCapNotify(self)

    def HasAwayNotify(self) -> "bool":
        return _znc_core.CClient_HasAwayNotify(self)

    def HasAccountNotify(self) -> "bool":
        return _znc_core.CClient_HasAccountNotify(self)

    def HasExtendedJoin(self) -> "bool":
        return _znc_core.CClient_HasExtendedJoin(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 HasEchoMessage(self) -> "bool":
        return _znc_core.CClient_HasEchoMessage(self)

    def HasSelfMessage(self) -> "bool":
        return _znc_core.CClient_HasSelfMessage(self)

    @staticmethod
    def IsValidIdentifier(sIdentifier: 'CString const &') -> "bool":
        return _znc_core.CClient_IsValidIdentifier(sIdentifier)

    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 PutClientRaw(self, sLine: 'CString const &') -> "bool":
        return _znc_core.CClient_PutClientRaw(self, sLine)

    def PutClient(self, *args) -> "bool":
        return _znc_core.CClient_PutClient(self, *args)

    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 IsTagEnabled(self, sTag: 'CString const &') -> "bool":
        return _znc_core.CClient_IsTagEnabled(self, sTag)

    def SetTagSupport(self, sTag: 'CString const &', bState: 'bool') -> "void":
        return _znc_core.CClient_SetTagSupport(self, sTag, bState)

    def NotifyServerDependentCaps(self, ssCaps: 'SCString') -> "void":
        return _znc_core.CClient_NotifyServerDependentCaps(self, ssCaps)

    def ClearServerDependentCaps(self) -> "void":
        return _znc_core.CClient_ClearServerDependentCaps(self)

    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)

# Register CClient in _znc_core:
_znc_core.CClient_swigregister(CClient)

def CClient_IsValidIdentifier(sIdentifier: 'CString const &') -> "bool":
    return _znc_core.CClient_IsValidIdentifier(sIdentifier)

class CIRCSock(CIRCSocket):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pNetwork: 'CIRCNetwork'):
        _znc_core.CIRCSock_swiginit(self, _znc_core.new_CIRCSock(pNetwork))
    __swig_destroy__ = _znc_core.delete_CIRCSock
    ListArg = _znc_core.CIRCSock_ListArg
    HasArg = _znc_core.CIRCSock_HasArg
    ArgWhenSet = _znc_core.CIRCSock_ArgWhenSet
    NoArg = _znc_core.CIRCSock_NoArg

    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 PutIRCRaw(self, sLine: 'CString const &') -> "void":
        return _znc_core.CIRCSock_PutIRCRaw(self, sLine)

    def PutIRC(self, *args) -> "void":
        return _znc_core.CIRCSock_PutIRC(self, *args)

    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 IsTagEnabled(self, sTag: 'CString const &') -> "bool":
        return _znc_core.CIRCSock_IsTagEnabled(self, sTag)

    def SetTagSupport(self, sTag: 'CString const &', bState: 'bool') -> "void":
        return _znc_core.CIRCSock_SetTagSupport(self, sTag, bState)

    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, cMode: 'char') -> "CIRCSock::EChanModeArgs":
        return _znc_core.CIRCSock_GetModeType(self, cMode)

    def GetPermFromMode(self, cMode: 'char') -> "char":
        return _znc_core.CIRCSock_GetPermFromMode(self, cMode)

    def GetChanModes(self) -> "std::map< char,CIRCSock::EChanModeArgs,std::less< char >,std::allocator< std::pair< 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 HasAwayNotify(self) -> "bool":
        return _znc_core.CIRCSock_HasAwayNotify(self)

    def HasAccountNotify(self) -> "bool":
        return _znc_core.CIRCSock_HasAccountNotify(self)

    def HasExtendedJoin(self) -> "bool":
        return _znc_core.CIRCSock_HasExtendedJoin(self)

    def HasServerTime(self) -> "bool":
        return _znc_core.CIRCSock_HasServerTime(self)

    def GetUserModes(self) -> "std::set< char,std::less< char >,std::allocator< char > > const &":
        return _znc_core.CIRCSock_GetUserModes(self)

    def IsAuthed(self) -> "bool":
        return _znc_core.CIRCSock_IsAuthed(self)

    def GetAcceptedCaps(self) -> "SCString const &":
        return _znc_core.CIRCSock_GetAcceptedCaps(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)

    @staticmethod
    def IsFloodProtected(fRate: 'double') -> "bool":
        return _znc_core.CIRCSock_IsFloodProtected(fRate)

# Register CIRCSock in _znc_core:
_znc_core.CIRCSock_swigregister(CIRCSock)

def CIRCSock_IsFloodProtected(fRate: 'double') -> "bool":
    return _znc_core.CIRCSock_IsFloodProtected(fRate)

class CListener(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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'):
        _znc_core.CListener_swiginit(self, _znc_core.new_CListener(uPort, sBindHost, sURIPrefix, bSSL, eAddr, eAccept))
    __swig_destroy__ = _znc_core.delete_CListener

    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)

# Register CListener in _znc_core:
_znc_core.CListener_swigregister(CListener)

class CRealListener(CZNCSock):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, listener: 'CListener'):
        _znc_core.CRealListener_swiginit(self, _znc_core.new_CRealListener(listener))
    __swig_destroy__ = _znc_core.delete_CRealListener

    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)

# Register CRealListener in _znc_core:
_znc_core.CRealListener_swigregister(CRealListener)

class CIncomingConnection(CZNCSock):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sHostname: 'CString const &', uPort: 'unsigned short', eAcceptType: 'CListener::EAcceptType', sURIPrefix: 'CString const &'):
        _znc_core.CIncomingConnection_swiginit(self, _znc_core.new_CIncomingConnection(sHostname, uPort, eAcceptType, sURIPrefix))
    __swig_destroy__ = _znc_core.delete_CIncomingConnection

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

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

# Register CIncomingConnection in _znc_core:
_znc_core.CIncomingConnection_swigregister(CIncomingConnection)

class CHTTPSock(CSocket):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    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)

    @staticmethod
    def ParseParams(sParams: 'CString const &', msvsParams: 'PyMStringVString') -> "void":
        return _znc_core.CHTTPSock_ParseParams(sParams, msvsParams)

    def ParseURI(self) -> "void":
        return _znc_core.CHTTPSock_ParseURI(self)

    def GetPage(self) -> "void":
        return _znc_core.CHTTPSock_GetPage(self)

    @staticmethod
    def GetDate(tm: 'time_t'=0) -> "CString":
        return _znc_core.CHTTPSock_GetDate(tm)

    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 GetURI(self) -> "CString const &":
        return _znc_core.CHTTPSock_GetURI(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)

# Register CHTTPSock in _znc_core:
_znc_core.CHTTPSock_swigregister(CHTTPSock)

def CHTTPSock_ParseParams(sParams: 'CString const &', msvsParams: 'PyMStringVString') -> "void":
    return _znc_core.CHTTPSock_ParseParams(sParams, msvsParams)

def CHTTPSock_GetDate(tm: 'time_t'=0) -> "CString":
    return _znc_core.CHTTPSock_GetDate(tm)

class CTemplateTagHandler(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CTemplateTagHandler_swiginit(self, _znc_core.new_CTemplateTagHandler())
    __swig_destroy__ = _znc_core.delete_CTemplateTagHandler

    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)

# Register CTemplateTagHandler in _znc_core:
_znc_core.CTemplateTagHandler_swigregister(CTemplateTagHandler)

class CTemplateOptions(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CTemplateOptions_swiginit(self, _znc_core.new_CTemplateOptions())
    __swig_destroy__ = _znc_core.delete_CTemplateOptions

    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)

# Register CTemplateOptions in _znc_core:
_znc_core.CTemplateOptions_swigregister(CTemplateOptions)

class CTemplateLoopContext(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _znc_core.delete_CTemplateLoopContext

    def __init__(self, *args):
        _znc_core.CTemplateLoopContext_swiginit(self, _znc_core.new_CTemplateLoopContext(*args))

    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)

# Register CTemplateLoopContext in _znc_core:
_znc_core.CTemplateLoopContext_swigregister(CTemplateLoopContext)

class CTemplate(MCString):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _znc_core.delete_CTemplate

    def __init__(self, *args):
        _znc_core.CTemplate_swiginit(self, _znc_core.new_CTemplate(*args))

    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)

# Register CTemplate in _znc_core:
_znc_core.CTemplate_swigregister(CTemplate)

class CZNCTagHandler(CTemplateTagHandler):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pWebSock: 'CWebSock'):
        _znc_core.CZNCTagHandler_swiginit(self, _znc_core.new_CZNCTagHandler(pWebSock))
    __swig_destroy__ = _znc_core.delete_CZNCTagHandler

    def HandleTag(self, Tmpl: 'CTemplate', sName: 'CString const &', sArgs: 'CString const &', sOutput: 'CString &') -> "bool":
        return _znc_core.CZNCTagHandler_HandleTag(self, Tmpl, sName, sArgs, sOutput)

# Register CZNCTagHandler in _znc_core:
_znc_core.CZNCTagHandler_swigregister(CZNCTagHandler)

class CWebSession(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sId: 'CString const &', sIP: 'CString const &'):
        _znc_core.CWebSession_swiginit(self, _znc_core.new_CWebSession(sId, sIP))
    __swig_destroy__ = _znc_core.delete_CWebSession

    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)

# Register CWebSession in _znc_core:
_znc_core.CWebSession_swigregister(CWebSession)

class CWebSubPage(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CWebSubPage_swiginit(self, _znc_core.new_CWebSubPage(*args))
    __swig_destroy__ = _znc_core.delete_CWebSubPage
    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: 'COptionalTranslation') -> "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":
        return _znc_core.CWebSubPage_GetTitle(self)

    def GetParams(self) -> "VPair const &":
        return _znc_core.CWebSubPage_GetParams(self)

# Register CWebSubPage in _znc_core:
_znc_core.CWebSubPage_swigregister(CWebSubPage)

class CWebSessionMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uTTL: 'unsigned int'=5000):
        _znc_core.CWebSessionMap_swiginit(self, _znc_core.new_CWebSessionMap(uTTL))

    def FinishUserSessions(self, User: 'CUser') -> "void":
        return _znc_core.CWebSessionMap_FinishUserSessions(self, User)
    __swig_destroy__ = _znc_core.delete_CWebSessionMap

# Register CWebSessionMap in _znc_core:
_znc_core.CWebSessionMap_swigregister(CWebSessionMap)

class CWebSock(CHTTPSock):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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 &'):
        _znc_core.CWebSock_swiginit(self, _znc_core.new_CWebSock(sURIPrefix))
    __swig_destroy__ = _znc_core.delete_CWebSock

    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)

    @staticmethod
    def GetSkinPath(sSkinName: 'CString const &') -> "CString":
        return _znc_core.CWebSock_GetSkinPath(sSkinName)

    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)

    @staticmethod
    def FinishUserSessions(User: 'CUser') -> "void":
        return _znc_core.CWebSock_FinishUserSessions(User)

    def GetCSRFCheck(self) -> "CString":
        return _znc_core.CWebSock_GetCSRFCheck(self)

    def ValidateCSRFCheck(self, sURI: 'CString const &') -> "bool":
        return _znc_core.CWebSock_ValidateCSRFCheck(self, sURI)

# Register CWebSock in _znc_core:
_znc_core.CWebSock_swigregister(CWebSock)

def CWebSock_GetSkinPath(sSkinName: 'CString const &') -> "CString":
    return _znc_core.CWebSock_GetSkinPath(sSkinName)

def CWebSock_FinishUserSessions(User: 'CUser') -> "void":
    return _znc_core.CWebSock_FinishUserSessions(User)

class CZNC(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CZNC_swiginit(self, _znc_core.new_CZNC())
    __swig_destroy__ = _znc_core.delete_CZNC
    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
    ECONFIG_DELAYED_WRITE = _znc_core.CZNC_ECONFIG_DELAYED_WRITE
    ECONFIG_NEED_QUIT = _znc_core.CZNC_ECONFIG_NEED_QUIT

    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)

    @staticmethod
    def GetVersion() -> "CString":
        return _znc_core.CZNC_GetVersion()

    @staticmethod
    def GetTag(bIncludeVersion: 'bool'=True, bHTML: 'bool'=False) -> "CString":
        return _znc_core.CZNC_GetTag(bIncludeVersion, bHTML)

    @staticmethod
    def GetCompileOptionsString() -> "CString":
        return _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 GetNetworkTrafficStats(self, sUsername: 'CString const &', Total: 'CZNC::TrafficStatsPair &') -> "CZNC::TrafficStatsMap":
        return _znc_core.CZNC_GetNetworkTrafficStats(self, sUsername, 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 SetAuthOnlyViaModule(self, b: 'bool') -> "void":
        return _znc_core.CZNC_SetAuthOnlyViaModule(self, b)

    def SetConnectDelay(self, i: 'unsigned int') -> "void":
        return _znc_core.CZNC_SetConnectDelay(self, i)

    def SetSSLCiphers(self, sCiphers: 'CString const &') -> "void":
        return _znc_core.CZNC_SetSSLCiphers(self, sCiphers)

    def SetSSLProtocols(self, sProtocols: 'CString const &') -> "bool":
        return _znc_core.CZNC_SetSSLProtocols(self, sProtocols)

    def SetSSLCertFile(self, sFile: 'CString const &') -> "void":
        return _znc_core.CZNC_SetSSLCertFile(self, sFile)

    def SetConfigWriteDelay(self, i: 'unsigned int') -> "void":
        return _znc_core.CZNC_SetConfigWriteDelay(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 GetKeyLocation(self) -> "CString":
        return _znc_core.CZNC_GetKeyLocation(self)

    def GetDHParamLocation(self) -> "CString":
        return _znc_core.CZNC_GetDHParamLocation(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 GetAuthOnlyViaModule(self) -> "bool":
        return _znc_core.CZNC_GetAuthOnlyViaModule(self)

    def GetSSLCiphers(self) -> "CString":
        return _znc_core.CZNC_GetSSLCiphers(self)

    def GetSSLProtocols(self) -> "CString":
        return _znc_core.CZNC_GetSSLProtocols(self)

    def GetDisabledSSLProtocols(self) -> "Csock::EDisableProtocol":
        return _znc_core.CZNC_GetDisabledSSLProtocols(self)

    def GetSSLCertFile(self) -> "CString":
        return _znc_core.CZNC_GetSSLCertFile(self)

    @staticmethod
    def GetAvailableSSLProtocols() -> "VCString":
        return _znc_core.CZNC_GetAvailableSSLProtocols()

    def GetConfigWriteDelay(self) -> "unsigned int":
        return _znc_core.CZNC_GetConfigWriteDelay(self)

    @staticmethod
    def CreateInstance() -> "void":
        return _znc_core.CZNC_CreateInstance()

    @staticmethod
    def Get() -> "CZNC &":
        return _znc_core.CZNC_Get()

    @staticmethod
    def DestroyInstance() -> "void":
        return _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 &', bStartup: 'bool'=False) -> "bool":
        return _znc_core.CZNC_AddUser(self, pUser, sErrorRet, bStartup)

    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 ForceEncoding(self) -> "void":
        return _znc_core.CZNC_ForceEncoding(self)

    def UnforceEncoding(self) -> "void":
        return _znc_core.CZNC_UnforceEncoding(self)

    def IsForcingEncoding(self) -> "bool":
        return _znc_core.CZNC_IsForcingEncoding(self)

    def FixupEncoding(self, sEncoding: 'CString const &') -> "CString":
        return _znc_core.CZNC_FixupEncoding(self, sEncoding)

    def LeakConnectQueueTimer(self, pTimer: 'CConnectQueueTimer *') -> "void":
        return _znc_core.CZNC_LeakConnectQueueTimer(self, pTimer)

    def DisableConfigTimer(self) -> "void":
        return _znc_core.CZNC_DisableConfigTimer(self)

    @staticmethod
    def DumpConfig(Config: 'CConfig') -> "void":
        return _znc_core.CZNC_DumpConfig(Config)

    def GetUserMap_(self) -> "PyObject *":
        return _znc_core.CZNC_GetUserMap_(self)

# Register CZNC in _znc_core:
_znc_core.CZNC_swigregister(CZNC)

def CZNC_GetVersion() -> "CString":
    return _znc_core.CZNC_GetVersion()

def CZNC_GetTag(bIncludeVersion: 'bool'=True, bHTML: 'bool'=False) -> "CString":
    return _znc_core.CZNC_GetTag(bIncludeVersion, bHTML)

def CZNC_GetCompileOptionsString() -> "CString":
    return _znc_core.CZNC_GetCompileOptionsString()

def CZNC_GetAvailableSSLProtocols() -> "VCString":
    return _znc_core.CZNC_GetAvailableSSLProtocols()

def CZNC_CreateInstance() -> "void":
    return _znc_core.CZNC_CreateInstance()

def CZNC_Get() -> "CZNC &":
    return _znc_core.CZNC_Get()

def CZNC_DestroyInstance() -> "void":
    return _znc_core.CZNC_DestroyInstance()

def CZNC_DumpConfig(Config: 'CConfig') -> "void":
    return _znc_core.CZNC_DumpConfig(Config)

class CServer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CServer_swiginit(self, _znc_core.new_CServer(*args))
    __swig_destroy__ = _znc_core.delete_CServer

    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)

    @staticmethod
    def IsValidHostName(sHostName: 'CString const &') -> "bool":
        return _znc_core.CServer_IsValidHostName(sHostName)

# Register CServer in _znc_core:
_znc_core.CServer_swigregister(CServer)

def CServer_IsValidHostName(sHostName: 'CString const &') -> "bool":
    return _znc_core.CServer_IsValidHostName(sHostName)

class CDebug(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    @staticmethod
    def SetStdoutIsTTY(b: 'bool') -> "void":
        return _znc_core.CDebug_SetStdoutIsTTY(b)

    @staticmethod
    def StdoutIsTTY() -> "bool":
        return _znc_core.CDebug_StdoutIsTTY()

    @staticmethod
    def SetDebug(b: 'bool') -> "void":
        return _znc_core.CDebug_SetDebug(b)

    @staticmethod
    def Debug() -> "bool":
        return _znc_core.CDebug_Debug()

    @staticmethod
    def Filter(sUnfilteredLine: 'CString const &') -> "CString":
        return _znc_core.CDebug_Filter(sUnfilteredLine)

    def __init__(self):
        _znc_core.CDebug_swiginit(self, _znc_core.new_CDebug())
    __swig_destroy__ = _znc_core.delete_CDebug

# Register CDebug in _znc_core:
_znc_core.CDebug_swigregister(CDebug)

def CDebug_SetStdoutIsTTY(b: 'bool') -> "void":
    return _znc_core.CDebug_SetStdoutIsTTY(b)

def CDebug_StdoutIsTTY() -> "bool":
    return _znc_core.CDebug_StdoutIsTTY()

def CDebug_SetDebug(b: 'bool') -> "void":
    return _znc_core.CDebug_SetDebug(b)

def CDebug_Debug() -> "bool":
    return _znc_core.CDebug_Debug()

def CDebug_Filter(sUnfilteredLine: 'CString const &') -> "CString":
    return _znc_core.CDebug_Filter(sUnfilteredLine)

class CDebugStream(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _znc_core.delete_CDebugStream

    def __init__(self):
        _znc_core.CDebugStream_swiginit(self, _znc_core.new_CDebugStream())

# Register CDebugStream in _znc_core:
_znc_core.CDebugStream_swigregister(CDebugStream)

class CExecSock(CZNCSock):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _znc_core.CExecSock_swiginit(self, _znc_core.new_CExecSock())

    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

    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)

# Register CExecSock in _znc_core:
_znc_core.CExecSock_swigregister(CExecSock)

class CBufLine(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.CBufLine_swiginit(self, _znc_core.new_CBufLine(*args))
    __swig_destroy__ = _znc_core.delete_CBufLine

    def ToMessage(self, Client: 'CClient', mssParams: 'MCString') -> "CMessage":
        return _znc_core.CBufLine_ToMessage(self, Client, mssParams)

    def GetLine(self, Client: 'CClient', mssParams: 'MCString') -> "CString":
        return _znc_core.CBufLine_GetLine(self, Client, mssParams)

    def UpdateTime(self) -> "void":
        return _znc_core.CBufLine_UpdateTime(self)

    def Equals(self, Format: 'CMessage') -> "bool":
        return _znc_core.CBufLine_Equals(self, Format)

    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 SetTags(self, mssTags: 'MCString') -> "void":
        return _znc_core.CBufLine_SetTags(self, mssTags)

    def GetCommand(self) -> "CString const &":
        return _znc_core.CBufLine_GetCommand(self)

    def GetFormat(self) -> "CString":
        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)

    def GetTags(self) -> "MCString const &":
        return _znc_core.CBufLine_GetTags(self)

# Register CBufLine in _znc_core:
_znc_core.CBufLine_swigregister(CBufLine)

class CBuffer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, uLineCount: 'unsigned int'=100):
        _znc_core.CBuffer_swiginit(self, _znc_core.new_CBuffer(uLineCount))
    __swig_destroy__ = _znc_core.delete_CBuffer

    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)

# Register CBuffer in _znc_core:
_znc_core.CBuffer_swigregister(CBuffer)

class String(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    s = property(_znc_core.String_s_get, _znc_core.String_s_set)

    def __init__(self, *args):
        _znc_core.String_swiginit(self, _znc_core.new_String(*args))

    def __str__(self) -> "CString":
        return _znc_core.String___str__(self)
    __swig_destroy__ = _znc_core.delete_String

# Register String in _znc_core:
_znc_core.String_swigregister(String)

class CPyModule(CModule):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pUser: 'CUser', pNetwork: 'CIRCNetwork', sModName: 'CString const &', sDataPath: 'CString const &', eType: 'CModInfo::EModuleType', pyObj: 'PyObject *', pModPython: 'CModPython'):
        _znc_core.CPyModule_swiginit(self, _znc_core.new_CPyModule(pUser, pNetwork, sModName, sDataPath, eType, pyObj, pModPython))

    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 ValidateWebRequestCSRFCheck(self, WebSock: 'CWebSock', sPageName: 'CString const &') -> "bool":
        return _znc_core.CPyModule_ValidateWebRequestCSRFCheck(self, WebSock, sPageName)

    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 OnUserQuit(self, sMessage: 'CString &') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserQuit(self, sMessage)

    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 OnRawMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnRawMessage(self, Message)

    def OnNumericMessage(self, Message: 'CNumericMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnNumericMessage(self, Message)

    def OnQuitMessage(self, Message: 'CQuitMessage', vChans: 'VChannels') -> "void":
        return _znc_core.CPyModule_OnQuitMessage(self, Message, vChans)

    def OnNickMessage(self, Message: 'CNickMessage', vChans: 'VChannels') -> "void":
        return _znc_core.CPyModule_OnNickMessage(self, Message, vChans)

    def OnKickMessage(self, Message: 'CKickMessage') -> "void":
        return _znc_core.CPyModule_OnKickMessage(self, Message)

    def OnJoinMessage(self, Message: 'CJoinMessage') -> "void":
        return _znc_core.CPyModule_OnJoinMessage(self, Message)

    def OnPartMessage(self, Message: 'CPartMessage') -> "void":
        return _znc_core.CPyModule_OnPartMessage(self, Message)

    def OnChanBufferPlayMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanBufferPlayMessage(self, Message)

    def OnPrivBufferPlayMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivBufferPlayMessage(self, Message)

    def OnUserRawMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserRawMessage(self, Message)

    def OnUserCTCPReplyMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserCTCPReplyMessage(self, Message)

    def OnUserCTCPMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserCTCPMessage(self, Message)

    def OnUserActionMessage(self, Message: 'CActionMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserActionMessage(self, Message)

    def OnUserTextMessage(self, Message: 'CTextMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserTextMessage(self, Message)

    def OnUserNoticeMessage(self, Message: 'CNoticeMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserNoticeMessage(self, Message)

    def OnUserJoinMessage(self, Message: 'CJoinMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserJoinMessage(self, Message)

    def OnUserPartMessage(self, Message: 'CPartMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserPartMessage(self, Message)

    def OnUserTopicMessage(self, Message: 'CTopicMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserTopicMessage(self, Message)

    def OnUserQuitMessage(self, Message: 'CQuitMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUserQuitMessage(self, Message)

    def OnCTCPReplyMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnCTCPReplyMessage(self, Message)

    def OnPrivCTCPMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivCTCPMessage(self, Message)

    def OnChanCTCPMessage(self, Message: 'CCTCPMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanCTCPMessage(self, Message)

    def OnPrivActionMessage(self, Message: 'CActionMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivActionMessage(self, Message)

    def OnChanActionMessage(self, Message: 'CActionMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanActionMessage(self, Message)

    def OnPrivTextMessage(self, Message: 'CTextMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivTextMessage(self, Message)

    def OnChanTextMessage(self, Message: 'CTextMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanTextMessage(self, Message)

    def OnPrivNoticeMessage(self, Message: 'CNoticeMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnPrivNoticeMessage(self, Message)

    def OnChanNoticeMessage(self, Message: 'CNoticeMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnChanNoticeMessage(self, Message)

    def OnTopicMessage(self, Message: 'CTopicMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnTopicMessage(self, Message)

    def OnSendToClientMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnSendToClientMessage(self, Message)

    def OnSendToIRCMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnSendToIRCMessage(self, Message)

    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 OnUnknownUserRawMessage(self, Message: 'CMessage') -> "CModule::EModRet":
        return _znc_core.CPyModule_OnUnknownUserRawMessage(self, Message)

    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

# Register CPyModule in _znc_core:
_znc_core.CPyModule_swigregister(CPyModule)


def AsPyModule(p: 'CModule') -> "CPyModule *":
    return _znc_core.AsPyModule(p)

def CreatePyModule(pUser: 'CUser', pNetwork: 'CIRCNetwork', sModName: 'CString const &', sDataPath: 'CString const &', eType: 'CModInfo::EModuleType', pyObj: 'PyObject *', pModPython: 'CModPython') -> "CPyModule *":
    return _znc_core.CreatePyModule(pUser, pNetwork, sModName, sDataPath, eType, pyObj, pModPython)
class CPyTimer(CTimer):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pModule: 'CPyModule', uInterval: 'unsigned int', uCycles: 'unsigned int', sLabel: 'CString const &', sDescription: 'CString const &', pyObj: 'PyObject *'):
        _znc_core.CPyTimer_swiginit(self, _znc_core.new_CPyTimer(pModule, uInterval, uCycles, sLabel, sDescription, pyObj))

    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

# Register CPyTimer in _znc_core:
_znc_core.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)
class CPySocket(CSocket):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pModule: 'CPyModule', pyObj: 'PyObject *'):
        _znc_core.CPySocket_swiginit(self, _znc_core.new_CPySocket(pModule, pyObj))

    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

    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)

# Register CPySocket in _znc_core:
_znc_core.CPySocket_swigregister(CPySocket)


def CreatePySocket(pModule: 'CPyModule', pyObj: 'PyObject *') -> "CPySocket *":
    return _znc_core.CreatePySocket(pModule, pyObj)

def HaveIPv6_() -> "bool":
    return _znc_core.HaveIPv6_()

def HaveSSL_() -> "bool":
    return _znc_core.HaveSSL_()

def HaveCharset_() -> "bool":
    return _znc_core.HaveCharset_()

def GetSOMAXCONN() -> "int":
    return _znc_core.GetSOMAXCONN()

def GetVersionMajor() -> "int":
    return _znc_core.GetVersionMajor()

def GetVersionMinor() -> "int":
    return _znc_core.GetVersionMinor()

def GetVersion() -> "double":
    return _znc_core.GetVersion()

def GetVersionExtra() -> "CString":
    return _znc_core.GetVersionExtra()
class MCString_iter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_znc_core.MCString_iter_x_get, _znc_core.MCString_iter_x_set)

    def __init__(self, *args):
        _znc_core.MCString_iter_swiginit(self, _znc_core.new_MCString_iter(*args))

    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

# Register MCString_iter in _znc_core:
_znc_core.MCString_iter_swigregister(MCString_iter)

class CModulesIter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pModules: 'CModules'):
        _znc_core.CModulesIter_swiginit(self, _znc_core.new_CModulesIter(pModules))

    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)
    m_pModules = property(_znc_core.CModulesIter_m_pModules_get, _znc_core.CModulesIter_m_pModules_set)
    m_it = property(_znc_core.CModulesIter_m_it_get, _znc_core.CModulesIter_m_it_set)
    __swig_destroy__ = _znc_core.delete_CModulesIter

# Register CModulesIter in _znc_core:
_znc_core.CModulesIter_swigregister(CModulesIter)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    s = 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

# Register CPyRetString in _znc_core:
_znc_core.CPyRetString_swigregister(CPyRetString)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    b = 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

# Register CPyRetBool in _znc_core:
_znc_core.CPyRetBool_swigregister(CPyRetBool)

class CModPython(CModule):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

# Register CModPython in _znc_core:
_znc_core.CModPython_swigregister(CModPython)

class StrPair(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _znc_core.StrPair_swiginit(self, _znc_core.new_StrPair(*args))
    first = property(_znc_core.StrPair_first_get, _znc_core.StrPair_first_set)
    second = 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

# Register StrPair in _znc_core:
_znc_core.StrPair_swigregister(StrPair)

class VPair(collections.abc.MutableSequence):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< std::pair< CString,CString > >::value_type":
        return _znc_core.VPair_pop(self)

    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 swap(self, v: 'VPair') -> "void":
        return _znc_core.VPair_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.VPair_clear(self)

    def get_allocator(self) -> "std::vector< std::pair< CString,CString > >::allocator_type":
        return _znc_core.VPair_get_allocator(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):
        _znc_core.VPair_swiginit(self, _znc_core.new_VPair(*args))

    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

# Register VPair in _znc_core:
_znc_core.VPair_swigregister(VPair)

class VWebSubPages(collections.abc.MutableSequence):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        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 __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 pop(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::value_type":
        return _znc_core.VWebSubPages_pop(self)

    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 swap(self, v: 'VWebSubPages') -> "void":
        return _znc_core.VWebSubPages_swap(self, v)

    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 clear(self) -> "void":
        return _znc_core.VWebSubPages_clear(self)

    def get_allocator(self) -> "std::vector< std::shared_ptr< CWebSubPage > >::allocator_type":
        return _znc_core.VWebSubPages_get_allocator(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):
        _znc_core.VWebSubPages_swiginit(self, _znc_core.new_VWebSubPages(*args))

    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

# Register VWebSubPages in _znc_core:
_znc_core.VWebSubPages_swigregister(VWebSubPages)


def VPair_Add2Str_(_self: 'VPair', a: 'CString const &', b: 'CString const &') -> "void":
    return _znc_core.VPair_Add2Str_(_self, a, b)

def CreateWebSubPage_(sName: 'CString const &', sTitle: 'CString const &', vParams: 'VPair', uFlags: 'unsigned int') -> "TWebSubPage":
    return _znc_core.CreateWebSubPage_(sName, sTitle, vParams, uFlags)


