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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _znc_core
else:
    import _znc_core

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core._stringlist_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core._stringlist___nonzero__(self)

    def __bool__(self):
        return _znc_core._stringlist___bool__(self)

    def __len__(self):
        return _znc_core._stringlist___len__(self)

    def __getslice__(self, i, j):
        return _znc_core._stringlist___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core._stringlist___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core._stringlist___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core._stringlist___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core._stringlist___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core._stringlist___setitem__(self, *args)

    def pop(self):
        return _znc_core._stringlist_pop(self)

    def append(self, x):
        return _znc_core._stringlist_append(self, x)

    def empty(self):
        return _znc_core._stringlist_empty(self)

    def size(self):
        return _znc_core._stringlist_size(self)

    def swap(self, v):
        return _znc_core._stringlist_swap(self, v)

    def begin(self):
        return _znc_core._stringlist_begin(self)

    def end(self):
        return _znc_core._stringlist_end(self)

    def rbegin(self):
        return _znc_core._stringlist_rbegin(self)

    def rend(self):
        return _znc_core._stringlist_rend(self)

    def clear(self):
        return _znc_core._stringlist_clear(self)

    def get_allocator(self):
        return _znc_core._stringlist_get_allocator(self)

    def pop_back(self):
        return _znc_core._stringlist_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core._stringlist_push_back(self, x)

    def front(self):
        return _znc_core._stringlist_front(self)

    def back(self):
        return _znc_core._stringlist_back(self)

    def assign(self, n, x):
        return _znc_core._stringlist_assign(self, n, x)

    def resize(self, *args):
        return _znc_core._stringlist_resize(self, *args)

    def insert(self, *args):
        return _znc_core._stringlist_insert(self, *args)

    def pop_front(self):
        return _znc_core._stringlist_pop_front(self)

    def push_front(self, x):
        return _znc_core._stringlist_push_front(self, x)

    def reverse(self):
        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):
        return _znc_core.VIRCNetworks_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VIRCNetworks___nonzero__(self)

    def __bool__(self):
        return _znc_core.VIRCNetworks___bool__(self)

    def __len__(self):
        return _znc_core.VIRCNetworks___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VIRCNetworks___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VIRCNetworks___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VIRCNetworks___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VIRCNetworks___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VIRCNetworks___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VIRCNetworks___setitem__(self, *args)

    def pop(self):
        return _znc_core.VIRCNetworks_pop(self)

    def append(self, x):
        return _znc_core.VIRCNetworks_append(self, x)

    def empty(self):
        return _znc_core.VIRCNetworks_empty(self)

    def size(self):
        return _znc_core.VIRCNetworks_size(self)

    def swap(self, v):
        return _znc_core.VIRCNetworks_swap(self, v)

    def begin(self):
        return _znc_core.VIRCNetworks_begin(self)

    def end(self):
        return _znc_core.VIRCNetworks_end(self)

    def rbegin(self):
        return _znc_core.VIRCNetworks_rbegin(self)

    def rend(self):
        return _znc_core.VIRCNetworks_rend(self)

    def clear(self):
        return _znc_core.VIRCNetworks_clear(self)

    def get_allocator(self):
        return _znc_core.VIRCNetworks_get_allocator(self)

    def pop_back(self):
        return _znc_core.VIRCNetworks_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VIRCNetworks_push_back(self, x)

    def front(self):
        return _znc_core.VIRCNetworks_front(self)

    def back(self):
        return _znc_core.VIRCNetworks_back(self)

    def assign(self, n, x):
        return _znc_core.VIRCNetworks_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VIRCNetworks_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VIRCNetworks_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VIRCNetworks_reserve(self, n)

    def capacity(self):
        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):
        return _znc_core.VChannels_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VChannels___nonzero__(self)

    def __bool__(self):
        return _znc_core.VChannels___bool__(self)

    def __len__(self):
        return _znc_core.VChannels___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VChannels___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VChannels___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VChannels___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VChannels___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VChannels___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VChannels___setitem__(self, *args)

    def pop(self):
        return _znc_core.VChannels_pop(self)

    def append(self, x):
        return _znc_core.VChannels_append(self, x)

    def empty(self):
        return _znc_core.VChannels_empty(self)

    def size(self):
        return _znc_core.VChannels_size(self)

    def swap(self, v):
        return _znc_core.VChannels_swap(self, v)

    def begin(self):
        return _znc_core.VChannels_begin(self)

    def end(self):
        return _znc_core.VChannels_end(self)

    def rbegin(self):
        return _znc_core.VChannels_rbegin(self)

    def rend(self):
        return _znc_core.VChannels_rend(self)

    def clear(self):
        return _znc_core.VChannels_clear(self)

    def get_allocator(self):
        return _znc_core.VChannels_get_allocator(self)

    def pop_back(self):
        return _znc_core.VChannels_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VChannels_push_back(self, x)

    def front(self):
        return _znc_core.VChannels_front(self)

    def back(self):
        return _znc_core.VChannels_back(self)

    def assign(self, n, x):
        return _znc_core.VChannels_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VChannels_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VChannels_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VChannels_reserve(self, n)

    def capacity(self):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.MNicks_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.MNicks___nonzero__(self)

    def __bool__(self):
        return _znc_core.MNicks___bool__(self)

    def __len__(self):
        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):
        return _znc_core.MNicks___getitem__(self, key)

    def __delitem__(self, key):
        return _znc_core.MNicks___delitem__(self, key)

    def has_key(self, key):
        return _znc_core.MNicks_has_key(self, key)

    def keys(self):
        return _znc_core.MNicks_keys(self)

    def values(self):
        return _znc_core.MNicks_values(self)

    def items(self):
        return _znc_core.MNicks_items(self)

    def __contains__(self, key):
        return _znc_core.MNicks___contains__(self, key)

    def key_iterator(self):
        return _znc_core.MNicks_key_iterator(self)

    def value_iterator(self):
        return _znc_core.MNicks_value_iterator(self)

    def __setitem__(self, *args):
        return _znc_core.MNicks___setitem__(self, *args)

    def asdict(self):
        return _znc_core.MNicks_asdict(self)

    def __init__(self, *args):
        _znc_core.MNicks_swiginit(self, _znc_core.new_MNicks(*args))

    def empty(self):
        return _znc_core.MNicks_empty(self)

    def size(self):
        return _znc_core.MNicks_size(self)

    def swap(self, v):
        return _znc_core.MNicks_swap(self, v)

    def begin(self):
        return _znc_core.MNicks_begin(self)

    def end(self):
        return _znc_core.MNicks_end(self)

    def rbegin(self):
        return _znc_core.MNicks_rbegin(self)

    def rend(self):
        return _znc_core.MNicks_rend(self)

    def clear(self):
        return _znc_core.MNicks_clear(self)

    def get_allocator(self):
        return _znc_core.MNicks_get_allocator(self)

    def count(self, x):
        return _znc_core.MNicks_count(self, x)

    def erase(self, *args):
        return _znc_core.MNicks_erase(self, *args)

    def find(self, x):
        return _znc_core.MNicks_find(self, x)

    def lower_bound(self, x):
        return _znc_core.MNicks_lower_bound(self, x)

    def upper_bound(self, x):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.SModInfo_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.SModInfo___nonzero__(self)

    def __bool__(self):
        return _znc_core.SModInfo___bool__(self)

    def __len__(self):
        return _znc_core.SModInfo___len__(self)

    def append(self, x):
        return _znc_core.SModInfo_append(self, x)

    def __contains__(self, x):
        return _znc_core.SModInfo___contains__(self, x)

    def __getitem__(self, i):
        return _znc_core.SModInfo___getitem__(self, i)

    def add(self, x):
        return _znc_core.SModInfo_add(self, x)

    def discard(self, x):
        return _znc_core.SModInfo_discard(self, x)

    def __init__(self, *args):
        _znc_core.SModInfo_swiginit(self, _znc_core.new_SModInfo(*args))

    def empty(self):
        return _znc_core.SModInfo_empty(self)

    def size(self):
        return _znc_core.SModInfo_size(self)

    def clear(self):
        return _znc_core.SModInfo_clear(self)

    def swap(self, v):
        return _znc_core.SModInfo_swap(self, v)

    def count(self, x):
        return _znc_core.SModInfo_count(self, x)

    def begin(self):
        return _znc_core.SModInfo_begin(self)

    def end(self):
        return _znc_core.SModInfo_end(self)

    def rbegin(self):
        return _znc_core.SModInfo_rbegin(self)

    def rend(self):
        return _znc_core.SModInfo_rend(self)

    def erase(self, *args):
        return _znc_core.SModInfo_erase(self, *args)

    def find(self, x):
        return _znc_core.SModInfo_find(self, x)

    def lower_bound(self, x):
        return _znc_core.SModInfo_lower_bound(self, x)

    def upper_bound(self, x):
        return _znc_core.SModInfo_upper_bound(self, x)

    def equal_range(self, x):
        return _znc_core.SModInfo_equal_range(self, x)

    def insert(self, __x):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.SCString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.SCString___nonzero__(self)

    def __bool__(self):
        return _znc_core.SCString___bool__(self)

    def __len__(self):
        return _znc_core.SCString___len__(self)

    def append(self, x):
        return _znc_core.SCString_append(self, x)

    def __contains__(self, x):
        return _znc_core.SCString___contains__(self, x)

    def __getitem__(self, i):
        return _znc_core.SCString___getitem__(self, i)

    def add(self, x):
        return _znc_core.SCString_add(self, x)

    def discard(self, x):
        return _znc_core.SCString_discard(self, x)

    def __init__(self, *args):
        _znc_core.SCString_swiginit(self, _znc_core.new_SCString(*args))

    def empty(self):
        return _znc_core.SCString_empty(self)

    def size(self):
        return _znc_core.SCString_size(self)

    def clear(self):
        return _znc_core.SCString_clear(self)

    def swap(self, v):
        return _znc_core.SCString_swap(self, v)

    def count(self, x):
        return _znc_core.SCString_count(self, x)

    def begin(self):
        return _znc_core.SCString_begin(self)

    def end(self):
        return _znc_core.SCString_end(self)

    def rbegin(self):
        return _znc_core.SCString_rbegin(self)

    def rend(self):
        return _znc_core.SCString_rend(self)

    def erase(self, *args):
        return _znc_core.SCString_erase(self, *args)

    def find(self, x):
        return _znc_core.SCString_find(self, x)

    def lower_bound(self, x):
        return _znc_core.SCString_lower_bound(self, x)

    def upper_bound(self, x):
        return _znc_core.SCString_upper_bound(self, x)

    def equal_range(self, x):
        return _znc_core.SCString_equal_range(self, x)

    def insert(self, __x):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.VCString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VCString___nonzero__(self)

    def __bool__(self):
        return _znc_core.VCString___bool__(self)

    def __len__(self):
        return _znc_core.VCString___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VCString___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VCString___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VCString___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VCString___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VCString___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VCString___setitem__(self, *args)

    def pop(self):
        return _znc_core.VCString_pop(self)

    def append(self, x):
        return _znc_core.VCString_append(self, x)

    def empty(self):
        return _znc_core.VCString_empty(self)

    def size(self):
        return _znc_core.VCString_size(self)

    def swap(self, v):
        return _znc_core.VCString_swap(self, v)

    def begin(self):
        return _znc_core.VCString_begin(self)

    def end(self):
        return _znc_core.VCString_end(self)

    def rbegin(self):
        return _znc_core.VCString_rbegin(self)

    def rend(self):
        return _znc_core.VCString_rend(self)

    def clear(self):
        return _znc_core.VCString_clear(self)

    def get_allocator(self):
        return _znc_core.VCString_get_allocator(self)

    def pop_back(self):
        return _znc_core.VCString_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VCString_push_back(self, x)

    def front(self):
        return _znc_core.VCString_front(self)

    def back(self):
        return _znc_core.VCString_back(self)

    def assign(self, n, x):
        return _znc_core.VCString_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VCString_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VCString_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VCString_reserve(self, n)

    def capacity(self):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.PyMCString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.PyMCString___nonzero__(self)

    def __bool__(self):
        return _znc_core.PyMCString___bool__(self)

    def __len__(self):
        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):
        return _znc_core.PyMCString___getitem__(self, key)

    def __delitem__(self, key):
        return _znc_core.PyMCString___delitem__(self, key)

    def has_key(self, key):
        return _znc_core.PyMCString_has_key(self, key)

    def keys(self):
        return _znc_core.PyMCString_keys(self)

    def values(self):
        return _znc_core.PyMCString_values(self)

    def items(self):
        return _znc_core.PyMCString_items(self)

    def __contains__(self, key):
        return _znc_core.PyMCString___contains__(self, key)

    def key_iterator(self):
        return _znc_core.PyMCString_key_iterator(self)

    def value_iterator(self):
        return _znc_core.PyMCString_value_iterator(self)

    def __setitem__(self, *args):
        return _znc_core.PyMCString___setitem__(self, *args)

    def asdict(self):
        return _znc_core.PyMCString_asdict(self)

    def __init__(self, *args):
        _znc_core.PyMCString_swiginit(self, _znc_core.new_PyMCString(*args))

    def empty(self):
        return _znc_core.PyMCString_empty(self)

    def size(self):
        return _znc_core.PyMCString_size(self)

    def swap(self, v):
        return _znc_core.PyMCString_swap(self, v)

    def begin(self):
        return _znc_core.PyMCString_begin(self)

    def end(self):
        return _znc_core.PyMCString_end(self)

    def rbegin(self):
        return _znc_core.PyMCString_rbegin(self)

    def rend(self):
        return _znc_core.PyMCString_rend(self)

    def clear(self):
        return _znc_core.PyMCString_clear(self)

    def get_allocator(self):
        return _znc_core.PyMCString_get_allocator(self)

    def count(self, x):
        return _znc_core.PyMCString_count(self, x)

    def erase(self, *args):
        return _znc_core.PyMCString_erase(self, *args)

    def find(self, x):
        return _znc_core.PyMCString_find(self, x)

    def lower_bound(self, x):
        return _znc_core.PyMCString_lower_bound(self, x)

    def upper_bound(self, x):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.PyMStringVString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.PyMStringVString___nonzero__(self)

    def __bool__(self):
        return _znc_core.PyMStringVString___bool__(self)

    def __len__(self):
        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):
        return _znc_core.PyMStringVString___getitem__(self, key)

    def __delitem__(self, key):
        return _znc_core.PyMStringVString___delitem__(self, key)

    def has_key(self, key):
        return _znc_core.PyMStringVString_has_key(self, key)

    def keys(self):
        return _znc_core.PyMStringVString_keys(self)

    def values(self):
        return _znc_core.PyMStringVString_values(self)

    def items(self):
        return _znc_core.PyMStringVString_items(self)

    def __contains__(self, key):
        return _znc_core.PyMStringVString___contains__(self, key)

    def key_iterator(self):
        return _znc_core.PyMStringVString_key_iterator(self)

    def value_iterator(self):
        return _znc_core.PyMStringVString_value_iterator(self)

    def __setitem__(self, *args):
        return _znc_core.PyMStringVString___setitem__(self, *args)

    def asdict(self):
        return _znc_core.PyMStringVString_asdict(self)

    def __init__(self, *args):
        _znc_core.PyMStringVString_swiginit(self, _znc_core.new_PyMStringVString(*args))

    def empty(self):
        return _znc_core.PyMStringVString_empty(self)

    def size(self):
        return _znc_core.PyMStringVString_size(self)

    def swap(self, v):
        return _znc_core.PyMStringVString_swap(self, v)

    def begin(self):
        return _znc_core.PyMStringVString_begin(self)

    def end(self):
        return _znc_core.PyMStringVString_end(self)

    def rbegin(self):
        return _znc_core.PyMStringVString_rbegin(self)

    def rend(self):
        return _znc_core.PyMStringVString_rend(self)

    def clear(self):
        return _znc_core.PyMStringVString_clear(self)

    def get_allocator(self):
        return _znc_core.PyMStringVString_get_allocator(self)

    def count(self, x):
        return _znc_core.PyMStringVString_count(self, x)

    def erase(self, *args):
        return _znc_core.PyMStringVString_erase(self, *args)

    def find(self, x):
        return _znc_core.PyMStringVString_find(self, x)

    def lower_bound(self, x):
        return _znc_core.PyMStringVString_lower_bound(self, x)

    def upper_bound(self, x):
        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):
        return _znc_core.PyModulesVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.PyModulesVector___nonzero__(self)

    def __bool__(self):
        return _znc_core.PyModulesVector___bool__(self)

    def __len__(self):
        return _znc_core.PyModulesVector___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.PyModulesVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.PyModulesVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.PyModulesVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.PyModulesVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.PyModulesVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.PyModulesVector___setitem__(self, *args)

    def pop(self):
        return _znc_core.PyModulesVector_pop(self)

    def append(self, x):
        return _znc_core.PyModulesVector_append(self, x)

    def empty(self):
        return _znc_core.PyModulesVector_empty(self)

    def size(self):
        return _znc_core.PyModulesVector_size(self)

    def swap(self, v):
        return _znc_core.PyModulesVector_swap(self, v)

    def begin(self):
        return _znc_core.PyModulesVector_begin(self)

    def end(self):
        return _znc_core.PyModulesVector_end(self)

    def rbegin(self):
        return _znc_core.PyModulesVector_rbegin(self)

    def rend(self):
        return _znc_core.PyModulesVector_rend(self)

    def clear(self):
        return _znc_core.PyModulesVector_clear(self)

    def get_allocator(self):
        return _znc_core.PyModulesVector_get_allocator(self)

    def pop_back(self):
        return _znc_core.PyModulesVector_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.PyModulesVector_push_back(self, x)

    def front(self):
        return _znc_core.PyModulesVector_front(self)

    def back(self):
        return _znc_core.PyModulesVector_back(self)

    def assign(self, n, x):
        return _znc_core.PyModulesVector_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.PyModulesVector_resize(self, *args)

    def insert(self, *args):
        return _znc_core.PyModulesVector_insert(self, *args)

    def reserve(self, n):
        return _znc_core.PyModulesVector_reserve(self, n)

    def capacity(self):
        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):
        return _znc_core.VListeners_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VListeners___nonzero__(self)

    def __bool__(self):
        return _znc_core.VListeners___bool__(self)

    def __len__(self):
        return _znc_core.VListeners___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VListeners___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VListeners___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VListeners___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VListeners___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VListeners___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VListeners___setitem__(self, *args)

    def pop(self):
        return _znc_core.VListeners_pop(self)

    def append(self, x):
        return _znc_core.VListeners_append(self, x)

    def empty(self):
        return _znc_core.VListeners_empty(self)

    def size(self):
        return _znc_core.VListeners_size(self)

    def swap(self, v):
        return _znc_core.VListeners_swap(self, v)

    def begin(self):
        return _znc_core.VListeners_begin(self)

    def end(self):
        return _znc_core.VListeners_end(self)

    def rbegin(self):
        return _znc_core.VListeners_rbegin(self)

    def rend(self):
        return _znc_core.VListeners_rend(self)

    def clear(self):
        return _znc_core.VListeners_clear(self)

    def get_allocator(self):
        return _znc_core.VListeners_get_allocator(self)

    def pop_back(self):
        return _znc_core.VListeners_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VListeners_push_back(self, x)

    def front(self):
        return _znc_core.VListeners_front(self)

    def back(self):
        return _znc_core.VListeners_back(self)

    def assign(self, n, x):
        return _znc_core.VListeners_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VListeners_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VListeners_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VListeners_reserve(self, n)

    def capacity(self):
        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):
        return _znc_core.BufLines_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.BufLines___nonzero__(self)

    def __bool__(self):
        return _znc_core.BufLines___bool__(self)

    def __len__(self):
        return _znc_core.BufLines___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.BufLines___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.BufLines___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.BufLines___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.BufLines___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.BufLines___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.BufLines___setitem__(self, *args)

    def pop(self):
        return _znc_core.BufLines_pop(self)

    def append(self, x):
        return _znc_core.BufLines_append(self, x)

    def empty(self):
        return _znc_core.BufLines_empty(self)

    def size(self):
        return _znc_core.BufLines_size(self)

    def swap(self, v):
        return _znc_core.BufLines_swap(self, v)

    def begin(self):
        return _znc_core.BufLines_begin(self)

    def end(self):
        return _znc_core.BufLines_end(self)

    def rbegin(self):
        return _znc_core.BufLines_rbegin(self)

    def rend(self):
        return _znc_core.BufLines_rend(self)

    def clear(self):
        return _znc_core.BufLines_clear(self)

    def get_allocator(self):
        return _znc_core.BufLines_get_allocator(self)

    def pop_back(self):
        return _znc_core.BufLines_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.BufLines_push_back(self, x)

    def front(self):
        return _znc_core.BufLines_front(self)

    def back(self):
        return _znc_core.BufLines_back(self)

    def assign(self, n, x):
        return _znc_core.BufLines_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.BufLines_resize(self, *args)

    def insert(self, *args):
        return _znc_core.BufLines_insert(self, *args)

    def pop_front(self):
        return _znc_core.BufLines_pop_front(self)

    def push_front(self, x):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.VVString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VVString___nonzero__(self)

    def __bool__(self):
        return _znc_core.VVString___bool__(self)

    def __len__(self):
        return _znc_core.VVString___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VVString___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VVString___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VVString___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VVString___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VVString___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VVString___setitem__(self, *args)

    def pop(self):
        return _znc_core.VVString_pop(self)

    def append(self, x):
        return _znc_core.VVString_append(self, x)

    def empty(self):
        return _znc_core.VVString_empty(self)

    def size(self):
        return _znc_core.VVString_size(self)

    def swap(self, v):
        return _znc_core.VVString_swap(self, v)

    def begin(self):
        return _znc_core.VVString_begin(self)

    def end(self):
        return _znc_core.VVString_end(self)

    def rbegin(self):
        return _znc_core.VVString_rbegin(self)

    def rend(self):
        return _znc_core.VVString_rend(self)

    def clear(self):
        return _znc_core.VVString_clear(self)

    def get_allocator(self):
        return _znc_core.VVString_get_allocator(self)

    def pop_back(self):
        return _znc_core.VVString_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VVString_push_back(self, x)

    def front(self):
        return _znc_core.VVString_front(self)

    def back(self):
        return _znc_core.VVString_back(self)

    def assign(self, n, x):
        return _znc_core.VVString_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VVString_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VVString_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VVString_reserve(self, n)

    def capacity(self):
        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):
        return _znc_core.VClients_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VClients___nonzero__(self)

    def __bool__(self):
        return _znc_core.VClients___bool__(self)

    def __len__(self):
        return _znc_core.VClients___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VClients___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VClients___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VClients___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VClients___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VClients___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VClients___setitem__(self, *args)

    def pop(self):
        return _znc_core.VClients_pop(self)

    def append(self, x):
        return _znc_core.VClients_append(self, x)

    def empty(self):
        return _znc_core.VClients_empty(self)

    def size(self):
        return _znc_core.VClients_size(self)

    def swap(self, v):
        return _znc_core.VClients_swap(self, v)

    def begin(self):
        return _znc_core.VClients_begin(self)

    def end(self):
        return _znc_core.VClients_end(self)

    def rbegin(self):
        return _znc_core.VClients_rbegin(self)

    def rend(self):
        return _znc_core.VClients_rend(self)

    def clear(self):
        return _znc_core.VClients_clear(self)

    def get_allocator(self):
        return _znc_core.VClients_get_allocator(self)

    def pop_back(self):
        return _znc_core.VClients_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VClients_push_back(self, x)

    def front(self):
        return _znc_core.VClients_front(self)

    def back(self):
        return _znc_core.VClients_back(self)

    def assign(self, n, x):
        return _znc_core.VClients_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VClients_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VClients_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VClients_reserve(self, n)

    def capacity(self):
        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):
        return _znc_core.VServers_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VServers___nonzero__(self)

    def __bool__(self):
        return _znc_core.VServers___bool__(self)

    def __len__(self):
        return _znc_core.VServers___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VServers___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VServers___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VServers___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VServers___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VServers___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VServers___setitem__(self, *args)

    def pop(self):
        return _znc_core.VServers_pop(self)

    def append(self, x):
        return _znc_core.VServers_append(self, x)

    def empty(self):
        return _znc_core.VServers_empty(self)

    def size(self):
        return _znc_core.VServers_size(self)

    def swap(self, v):
        return _znc_core.VServers_swap(self, v)

    def begin(self):
        return _znc_core.VServers_begin(self)

    def end(self):
        return _znc_core.VServers_end(self)

    def rbegin(self):
        return _znc_core.VServers_rbegin(self)

    def rend(self):
        return _znc_core.VServers_rend(self)

    def clear(self):
        return _znc_core.VServers_clear(self)

    def get_allocator(self):
        return _znc_core.VServers_get_allocator(self)

    def pop_back(self):
        return _znc_core.VServers_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VServers_push_back(self, x)

    def front(self):
        return _znc_core.VServers_front(self)

    def back(self):
        return _znc_core.VServers_back(self)

    def assign(self, n, x):
        return _znc_core.VServers_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VServers_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VServers_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VServers_reserve(self, n)

    def capacity(self):
        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):
        return _znc_core.VQueries_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VQueries___nonzero__(self)

    def __bool__(self):
        return _znc_core.VQueries___bool__(self)

    def __len__(self):
        return _znc_core.VQueries___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VQueries___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VQueries___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VQueries___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VQueries___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VQueries___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VQueries___setitem__(self, *args)

    def pop(self):
        return _znc_core.VQueries_pop(self)

    def append(self, x):
        return _znc_core.VQueries_append(self, x)

    def empty(self):
        return _znc_core.VQueries_empty(self)

    def size(self):
        return _znc_core.VQueries_size(self)

    def swap(self, v):
        return _znc_core.VQueries_swap(self, v)

    def begin(self):
        return _znc_core.VQueries_begin(self)

    def end(self):
        return _znc_core.VQueries_end(self)

    def rbegin(self):
        return _znc_core.VQueries_rbegin(self)

    def rend(self):
        return _znc_core.VQueries_rend(self)

    def clear(self):
        return _znc_core.VQueries_clear(self)

    def get_allocator(self):
        return _znc_core.VQueries_get_allocator(self)

    def pop_back(self):
        return _znc_core.VQueries_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VQueries_push_back(self, x)

    def front(self):
        return _znc_core.VQueries_front(self)

    def back(self):
        return _znc_core.VQueries_back(self)

    def assign(self, n, x):
        return _znc_core.VQueries_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VQueries_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VQueries_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VQueries_reserve(self, n)

    def capacity(self):
        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():
        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)
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():
        return _znc_core.CTranslation_Get()

    def Singular(self, sDomain, sContext, sEnglish):
        return _znc_core.CTranslation_Singular(self, sDomain, sContext, sEnglish)

    def Plural(self, sDomain, sContext, sEnglish, sEnglishes, iNum):
        return _znc_core.CTranslation_Plural(self, sDomain, sContext, sEnglish, sEnglishes, iNum)

    def PushLanguage(self, sLanguage):
        return _znc_core.CTranslation_PushLanguage(self, sLanguage)

    def PopLanguage(self):
        return _znc_core.CTranslation_PopLanguage(self)

    def NewReference(self, sDomain):
        return _znc_core.CTranslation_NewReference(self, sDomain)

    def DelReference(self, sDomain):
        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)
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):
        _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):
        _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):
        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):
        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):
    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):
        return _znc_core.CUtils_GetIP(addr)

    @staticmethod
    def GetLongIP(sIP):
        return _znc_core.CUtils_GetLongIP(sIP)

    @staticmethod
    def PrintError(sMessage):
        return _znc_core.CUtils_PrintError(sMessage)

    @staticmethod
    def PrintMessage(sMessage, bStrong=False):
        return _znc_core.CUtils_PrintMessage(sMessage, bStrong)

    @staticmethod
    def PrintPrompt(sMessage):
        return _znc_core.CUtils_PrintPrompt(sMessage)

    @staticmethod
    def PrintAction(sMessage):
        return _znc_core.CUtils_PrintAction(sMessage)

    @staticmethod
    def PrintStatus(*args):
        return _znc_core.CUtils_PrintStatus(*args)

    @staticmethod
    def AskSaltedHashPassForConfig():
        return _znc_core.CUtils_AskSaltedHashPassForConfig()

    @staticmethod
    def GetSalt():
        return _znc_core.CUtils_GetSalt()

    @staticmethod
    def SaltedMD5Hash(sPass, sSalt):
        return _znc_core.CUtils_SaltedMD5Hash(sPass, sSalt)

    @staticmethod
    def SaltedSHA256Hash(sPass, sSalt):
        return _znc_core.CUtils_SaltedSHA256Hash(sPass, sSalt)

    @staticmethod
    def SaltedHash(sPass, sSalt):
        return _znc_core.CUtils_SaltedHash(sPass, sSalt)

    @staticmethod
    def GetPass(sPrompt):
        return _znc_core.CUtils_GetPass(sPrompt)

    @staticmethod
    def GetInput(*args):
        return _znc_core.CUtils_GetInput(*args)

    @staticmethod
    def GetBoolInput(*args):
        return _znc_core.CUtils_GetBoolInput(*args)

    @staticmethod
    def GetNumInput(*args):
        return _znc_core.CUtils_GetNumInput(*args)

    @staticmethod
    def GetTime():
        return _znc_core.CUtils_GetTime()

    @staticmethod
    def GetMillTime():
        return _znc_core.CUtils_GetMillTime()

    @staticmethod
    def CTime(t, sTZ):
        return _znc_core.CUtils_CTime(t, sTZ)

    @staticmethod
    def FormatTime(*args):
        return _znc_core.CUtils_FormatTime(*args)

    @staticmethod
    def FormatServerTime(tv):
        return _znc_core.CUtils_FormatServerTime(tv)

    @staticmethod
    def ParseServerTime(sTime):
        return _znc_core.CUtils_ParseServerTime(sTime)

    @staticmethod
    def GetTimezones():
        return _znc_core.CUtils_GetTimezones()

    @staticmethod
    def GetEncodings():
        return _znc_core.CUtils_GetEncodings()

    @staticmethod
    def CheckCIDR(sIP, sRange):
        return _znc_core.CUtils_CheckCIDR(sIP, sRange)

    @staticmethod
    def GetMessageTags(sLine):
        return _znc_core.CUtils_GetMessageTags(sLine)

    @staticmethod
    def SetMessageTags(sLine, mssTags):
        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

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):
        _znc_core.CException_swiginit(self, _znc_core.new_CException(e))
    __swig_destroy__ = _znc_core.delete_CException

    def GetType(self):
        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):
        return _znc_core.CTable_AddColumn(self, sName)

    def SetStyle(self, eNewStyle):
        return _znc_core.CTable_SetStyle(self, eNewStyle)

    def AddRow(self):
        return _znc_core.CTable_AddRow(self)

    def SetCell(self, *args):
        return _znc_core.CTable_SetCell(self, *args)

    def GetLine(self, uIdx, sLine):
        return _znc_core.CTable_GetLine(self, uIdx, sLine)

    def GetColumnWidth(self, uIdx):
        return _znc_core.CTable_GetColumnWidth(self, uIdx)

    def Clear(self):
        return _znc_core.CTable_Clear(self)

    def size(self):
        return _znc_core.CTable_size(self)

    def empty(self):
        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):
        return _znc_core.CConfig_BeginEntries(self)

    def EndEntries(self):
        return _znc_core.CConfig_EndEntries(self)

    def BeginSubConfigs(self):
        return _znc_core.CConfig_BeginSubConfigs(self)

    def EndSubConfigs(self):
        return _znc_core.CConfig_EndSubConfigs(self)

    def AddKeyValuePair(self, sName, sValue):
        return _znc_core.CConfig_AddKeyValuePair(self, sName, sValue)

    def AddSubConfig(self, sTag, sName, Config):
        return _znc_core.CConfig_AddSubConfig(self, sTag, sName, Config)

    def FindStringVector(self, sName, vsList, bErase=True):
        return _znc_core.CConfig_FindStringVector(self, sName, vsList, bErase)

    def FindStringEntry(self, *args):
        return _znc_core.CConfig_FindStringEntry(self, *args)

    def FindBoolEntry(self, sName, bRes, bDefault=False):
        return _znc_core.CConfig_FindBoolEntry(self, sName, bRes, bDefault)

    def FindUIntEntry(self, sName, uRes, uDefault=0):
        return _znc_core.CConfig_FindUIntEntry(self, sName, uRes, uDefault)

    def FindUShortEntry(self, sName, uRes, uDefault=0):
        return _znc_core.CConfig_FindUShortEntry(self, sName, uRes, uDefault)

    def FindDoubleEntry(self, sName, fRes, fDefault=0):
        return _znc_core.CConfig_FindDoubleEntry(self, sName, fRes, fDefault)

    def FindSubConfig(self, sTag, Config, bErase=True):
        return _znc_core.CConfig_FindSubConfig(self, sTag, Config, bErase)

    def empty(self):
        return _znc_core.CConfig_empty(self)

    def Parse(self, file, sErrorMsg):
        return _znc_core.CConfig_Parse(self, file, sErrorMsg)

    def Write(self, file, iIndentation=0):
        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):
        _znc_core.CSCharBuffer_swiginit(self, _znc_core.new_CSCharBuffer(iSize))
    __swig_destroy__ = _znc_core.delete_CSCharBuffer

    def __call__(self):
        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):
        return _znc_core.CSSockAddr_SinFamily(self)

    def SinPort(self, iPort):
        return _znc_core.CSSockAddr_SinPort(self, iPort)

    def SetIPv6(self, b):
        return _znc_core.CSSockAddr_SetIPv6(self, b)

    def GetIPv6(self):
        return _znc_core.CSSockAddr_GetIPv6(self)

    def GetSockAddrLen(self):
        return _znc_core.CSSockAddr_GetSockAddrLen(self)

    def GetSockAddr(self):
        return _znc_core.CSSockAddr_GetSockAddr(self)

    def GetAddr(self):
        return _znc_core.CSSockAddr_GetAddr(self)

    def SetAFRequire(self, iWhich):
        return _znc_core.CSSockAddr_SetAFRequire(self, iWhich)

    def GetAFRequire(self):
        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, pSock, csSockAddr):
        _znc_core.CGetAddrInfo_swiginit(self, _znc_core.new_CGetAddrInfo(sHostname, pSock, csSockAddr))
    __swig_destroy__ = _znc_core.delete_CGetAddrInfo

    def Init(self):
        return _znc_core.CGetAddrInfo_Init(self)

    def Process(self):
        return _znc_core.CGetAddrInfo_Process(self)

    def Finish(self):
        return _znc_core.CGetAddrInfo_Finish(self)

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

def CS_GetAddrInfo(sHostname, pSock, csSockAddr):
    return _znc_core.CS_GetAddrInfo(sHostname, pSock, csSockAddr)

def GetCsockSSLIdx():
    return _znc_core.GetCsockSSLIdx()

def InitCsocket():
    return _znc_core.InitCsocket()

def ShutdownCsocket():
    return _znc_core.ShutdownCsocket()

def GetSockError():
    return _znc_core.GetSockError()

def TFD_ZERO(set):
    return _znc_core.TFD_ZERO(set)

def TFD_SET(iSock, set):
    return _znc_core.TFD_SET(iSock, set)

def TFD_ISSET(iSock, set):
    return _znc_core.TFD_ISSET(iSock, set)

def TFD_CLR(iSock, set):
    return _znc_core.TFD_CLR(iSock, set)

def __Perror(s, pszFile, iLineNo):
    return _znc_core.__Perror(s, pszFile, iLineNo)
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):
        return _znc_core.CCron_run(self, tNow)

    def StartMaxCycles(self, *args):
        return _znc_core.CCron_StartMaxCycles(self, *args)

    def Start(self, *args):
        return _znc_core.CCron_Start(self, *args)

    def Stop(self):
        return _znc_core.CCron_Stop(self)

    def Pause(self):
        return _znc_core.CCron_Pause(self)

    def UnPause(self):
        return _znc_core.CCron_UnPause(self)

    def Reset(self):
        return _znc_core.CCron_Reset(self)

    def GetInterval(self):
        return _znc_core.CCron_GetInterval(self)

    def GetMaxCycles(self):
        return _znc_core.CCron_GetMaxCycles(self)

    def GetCyclesLeft(self):
        return _znc_core.CCron_GetCyclesLeft(self)

    def isValid(self):
        return _znc_core.CCron_isValid(self)

    def GetName(self):
        return _znc_core.CCron_GetName(self)

    def SetName(self, sName):
        return _znc_core.CCron_SetName(self, sName)

    def GetNextRun(self):
        return _znc_core.CCron_GetNextRun(self)

    def RunJob(self):
        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, iTimeoutMS):
        return _znc_core.CSMonitorFD_GatherFDsForSelect(self, miiReadyFds, iTimeoutMS)

    def FDsThatTriggered(self, miiReadyFds):
        return _znc_core.CSMonitorFD_FDsThatTriggered(self, miiReadyFds)

    def CheckFDs(self, miiReadyFds):
        return _znc_core.CSMonitorFD_CheckFDs(self, miiReadyFds)

    def Add(self, iFD, iMonitorEvents):
        return _znc_core.CSMonitorFD_Add(self, iFD, iMonitorEvents)

    def Remove(self, iFD):
        return _znc_core.CSMonitorFD_Remove(self, iFD)

    def DisableMonitor(self):
        return _znc_core.CSMonitorFD_DisableMonitor(self)

    def IsEnabled(self):
        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):
        return _znc_core.CSockCommon_CleanupCrons(self)

    def CleanupFDMonitors(self):
        return _znc_core.CSockCommon_CleanupFDMonitors(self)

    def GetCrons(self):
        return _znc_core.CSockCommon_GetCrons(self)

    def Cron(self):
        return _znc_core.CSockCommon_Cron(self)

    def AddCron(self, pcCron):
        return _znc_core.CSockCommon_AddCron(self, pcCron)

    def DelCron(self, *args):
        return _znc_core.CSockCommon_DelCron(self, *args)

    def DelCronByAddr(self, pcCron):
        return _znc_core.CSockCommon_DelCronByAddr(self, pcCron)

    def CheckFDs(self, miiReadyFds):
        return _znc_core.CSockCommon_CheckFDs(self, miiReadyFds)

    def AssignFDs(self, miiReadyFds, tvtimeout):
        return _znc_core.CSockCommon_AssignFDs(self, miiReadyFds, tvtimeout)

    def MonitorFD(self, pMonitorFD):
        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, iPort):
        return _znc_core.Csock_GetSockObj(self, sHostname, iPort)
    __swig_destroy__ = _znc_core.delete_Csock

    def Dereference(self):
        return _znc_core.Csock_Dereference(self)

    def Copy(self, cCopy):
        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):
        return _znc_core.Csock___lshift__(self, *args)

    def Connect(self):
        return _znc_core.Csock_Connect(self)

    def ConnectUnix(self, sPath):
        return _znc_core.Csock_ConnectUnix(self, sPath)

    def ListenUnix(self, *args):
        return _znc_core.Csock_ListenUnix(self, *args)

    def Listen(self, *args):
        return _znc_core.Csock_Listen(self, *args)

    def Accept(self, sHost, iRPort):
        return _znc_core.Csock_Accept(self, sHost, iRPort)

    def AcceptSSL(self):
        return _znc_core.Csock_AcceptSSL(self)

    def SSLClientSetup(self):
        return _znc_core.Csock_SSLClientSetup(self)

    def SSLServerSetup(self):
        return _znc_core.Csock_SSLServerSetup(self)

    def ConnectSSL(self):
        return _znc_core.Csock_ConnectSSL(self)

    def StartTLS(self):
        return _znc_core.Csock_StartTLS(self)

    def Write(self, *args):
        return _znc_core.Csock_Write(self, *args)

    def Read(self, data, len):
        return _znc_core.Csock_Read(self, data, len)

    def GetLocalIP(self):
        return _znc_core.Csock_GetLocalIP(self)

    def GetRemoteIP(self):
        return _znc_core.Csock_GetRemoteIP(self)

    def IsConnected(self):
        return _znc_core.Csock_IsConnected(self)

    def SetIsConnected(self, b):
        return _znc_core.Csock_SetIsConnected(self, b)

    def GetRSock(self, *args):
        return _znc_core.Csock_GetRSock(self, *args)

    def SetRSock(self, iSock):
        return _znc_core.Csock_SetRSock(self, iSock)

    def GetWSock(self, *args):
        return _znc_core.Csock_GetWSock(self, *args)

    def SetWSock(self, iSock):
        return _znc_core.Csock_SetWSock(self, iSock)

    def SetSock(self, iSock):
        return _znc_core.Csock_SetSock(self, iSock)

    def GetSock(self, *args):
        return _znc_core.Csock_GetSock(self, *args)

    def CallSockError(self, *args):
        return _znc_core.Csock_CallSockError(self, *args)

    def ResetTimer(self):
        return _znc_core.Csock_ResetTimer(self)

    def PauseRead(self):
        return _znc_core.Csock_PauseRead(self)

    def UnPauseRead(self):
        return _znc_core.Csock_UnPauseRead(self)

    def IsReadPaused(self):
        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):
        return _znc_core.Csock_SetTimeout(self, *args)

    def SetTimeoutType(self, iTimeoutType):
        return _znc_core.Csock_SetTimeoutType(self, iTimeoutType)

    def GetTimeout(self):
        return _znc_core.Csock_GetTimeout(self)

    def GetTimeoutType(self):
        return _znc_core.Csock_GetTimeoutType(self)

    def CheckTimeout(self, iNow):
        return _znc_core.Csock_CheckTimeout(self, iNow)

    def PushBuff(self, data, len, bStartAtZero=False):
        return _znc_core.Csock_PushBuff(self, data, len, bStartAtZero)

    def GetInternalReadBuffer(self):
        return _znc_core.Csock_GetInternalReadBuffer(self)

    def GetInternalWriteBuffer(self):
        return _znc_core.Csock_GetInternalWriteBuffer(self)

    def SetMaxBufferThreshold(self, iThreshold):
        return _znc_core.Csock_SetMaxBufferThreshold(self, iThreshold)

    def GetMaxBufferThreshold(self):
        return _znc_core.Csock_GetMaxBufferThreshold(self)

    def GetType(self):
        return _znc_core.Csock_GetType(self)

    def SetType(self, iType):
        return _znc_core.Csock_SetType(self, iType)

    def GetSockName(self):
        return _znc_core.Csock_GetSockName(self)

    def SetSockName(self, sName):
        return _znc_core.Csock_SetSockName(self, sName)

    def GetHostName(self):
        return _znc_core.Csock_GetHostName(self)

    def SetHostName(self, sHostname):
        return _znc_core.Csock_SetHostName(self, sHostname)

    def GetStartTime(self):
        return _znc_core.Csock_GetStartTime(self)

    def ResetStartTime(self):
        return _znc_core.Csock_ResetStartTime(self)

    def GetBytesRead(self):
        return _znc_core.Csock_GetBytesRead(self)

    def ResetBytesRead(self):
        return _znc_core.Csock_ResetBytesRead(self)

    def GetBytesWritten(self):
        return _znc_core.Csock_GetBytesWritten(self)

    def ResetBytesWritten(self):
        return _znc_core.Csock_ResetBytesWritten(self)

    def GetAvgRead(self, iSample=1000):
        return _znc_core.Csock_GetAvgRead(self, iSample)

    def GetAvgWrite(self, iSample=1000):
        return _znc_core.Csock_GetAvgWrite(self, iSample)

    def GetRemotePort(self):
        return _znc_core.Csock_GetRemotePort(self)

    def GetLocalPort(self):
        return _znc_core.Csock_GetLocalPort(self)

    def GetPort(self):
        return _znc_core.Csock_GetPort(self)

    def SetPort(self, iPort):
        return _znc_core.Csock_SetPort(self, iPort)

    def Close(self, *args):
        return _znc_core.Csock_Close(self, *args)

    def GetCloseType(self):
        return _znc_core.Csock_GetCloseType(self)

    def IsClosed(self):
        return _znc_core.Csock_IsClosed(self)

    def NonBlockingIO(self):
        return _znc_core.Csock_NonBlockingIO(self)

    def GetSSL(self):
        return _znc_core.Csock_GetSSL(self)

    def SetSSL(self, b):
        return _znc_core.Csock_SetSSL(self, b)

    def HasWriteBuffer(self):
        return _znc_core.Csock_HasWriteBuffer(self)

    def ClearWriteBuffer(self):
        return _znc_core.Csock_ClearWriteBuffer(self)

    def SslIsEstablished(self):
        return _znc_core.Csock_SslIsEstablished(self)

    def ConnectInetd(self, *args):
        return _znc_core.Csock_ConnectInetd(self, *args)

    def ConnectFD(self, *args):
        return _znc_core.Csock_ConnectFD(self, *args)

    def SetParentSockName(self, sParentName):
        return _znc_core.Csock_SetParentSockName(self, sParentName)

    def GetParentSockName(self):
        return _znc_core.Csock_GetParentSockName(self)

    def SetRate(self, iBytes, iMilliseconds):
        return _znc_core.Csock_SetRate(self, iBytes, iMilliseconds)

    def GetRateBytes(self):
        return _znc_core.Csock_GetRateBytes(self)

    def GetRateTime(self):
        return _znc_core.Csock_GetRateTime(self)

    def Connected(self):
        return _znc_core.Csock_Connected(self)

    def Disconnected(self):
        return _znc_core.Csock_Disconnected(self)

    def Timeout(self):
        return _znc_core.Csock_Timeout(self)

    def ReadData(self, data, len):
        return _znc_core.Csock_ReadData(self, data, len)

    def ReadLine(self, sLine):
        return _znc_core.Csock_ReadLine(self, sLine)

    def EnableReadLine(self):
        return _znc_core.Csock_EnableReadLine(self)

    def DisableReadLine(self):
        return _znc_core.Csock_DisableReadLine(self)

    def HasReadLine(self):
        return _znc_core.Csock_HasReadLine(self)

    def ReachedMaxBuffer(self):
        return _znc_core.Csock_ReachedMaxBuffer(self)

    def SockError(self, iErrno, sDescription):
        return _znc_core.Csock_SockError(self, iErrno, sDescription)

    def ConnectionFrom(self, sHost, iPort):
        return _znc_core.Csock_ConnectionFrom(self, sHost, iPort)

    def Listening(self, sBindIP, uPort):
        return _znc_core.Csock_Listening(self, sBindIP, uPort)

    def ConnectionRefused(self):
        return _znc_core.Csock_ConnectionRefused(self)

    def ReadPaused(self):
        return _znc_core.Csock_ReadPaused(self)

    def GetTimeSinceLastDataTransaction(self, iNow=0):
        return _znc_core.Csock_GetTimeSinceLastDataTransaction(self, iNow)

    def GetLastCheckTimeout(self):
        return _znc_core.Csock_GetLastCheckTimeout(self)

    def GetNextCheckTimeout(self, iNow=0):
        return _znc_core.Csock_GetNextCheckTimeout(self, iNow)

    def GetPending(self):
        return _znc_core.Csock_GetPending(self)

    def GetConState(self):
        return _znc_core.Csock_GetConState(self)

    def SetConState(self, eState):
        return _znc_core.Csock_SetConState(self, eState)

    def CreateSocksFD(self):
        return _znc_core.Csock_CreateSocksFD(self)

    def CloseSocksFD(self):
        return _znc_core.Csock_CloseSocksFD(self)

    def GetBindHost(self):
        return _znc_core.Csock_GetBindHost(self)

    def SetBindHost(self, sBindHost):
        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):
        return _znc_core.Csock_DNSLookup(self, eDNSLType)

    def SetupVHost(self):
        return _znc_core.Csock_SetupVHost(self)

    def GetIPv6(self):
        return _znc_core.Csock_GetIPv6(self)

    def SetIPv6(self, b):
        return _znc_core.Csock_SetIPv6(self, b)

    def SetAFRequire(self, iAFRequire):
        return _znc_core.Csock_SetAFRequire(self, iAFRequire)

    def AllowWrite(self, iNOW):
        return _znc_core.Csock_AllowWrite(self, iNOW)

    def SetSkipConnect(self, b):
        return _znc_core.Csock_SetSkipConnect(self, b)

    def GetAddrInfo(self, sHostname, csSockAddr):
        return _znc_core.Csock_GetAddrInfo(self, sHostname, csSockAddr)

    def ConvertAddress(self, pAddr, iAddrLen, sIP, piPort):
        return _znc_core.Csock_ConvertAddress(self, pAddr, iAddrLen, sIP, piPort)

    def GetMaxConns(self):
        return _znc_core.Csock_GetMaxConns(self)

    def WriteBytes(self, data):
        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, iPort, iTimeout=60):
        _znc_core.CSConnection_swiginit(self, _znc_core.new_CSConnection(sHostname, iPort, iTimeout))
    __swig_destroy__ = _znc_core.delete_CSConnection

    def GetHostname(self):
        return _znc_core.CSConnection_GetHostname(self)

    def GetSockName(self):
        return _znc_core.CSConnection_GetSockName(self)

    def GetBindHost(self):
        return _znc_core.CSConnection_GetBindHost(self)

    def GetPort(self):
        return _znc_core.CSConnection_GetPort(self)

    def GetTimeout(self):
        return _znc_core.CSConnection_GetTimeout(self)

    def GetIsSSL(self):
        return _znc_core.CSConnection_GetIsSSL(self)

    def GetAFRequire(self):
        return _znc_core.CSConnection_GetAFRequire(self)

    def SetHostname(self, s):
        return _znc_core.CSConnection_SetHostname(self, s)

    def SetSockName(self, s):
        return _znc_core.CSConnection_SetSockName(self, s)

    def SetBindHost(self, s):
        return _znc_core.CSConnection_SetBindHost(self, s)

    def SetPort(self, i):
        return _znc_core.CSConnection_SetPort(self, i)

    def SetTimeout(self, i):
        return _znc_core.CSConnection_SetTimeout(self, i)

    def SetIsSSL(self, b):
        return _znc_core.CSConnection_SetIsSSL(self, b)

    def SetAFRequire(self, iAFRequire):
        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, iPort, iTimeout=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):
        return _znc_core.CSListener_SetDetach(self, b)

    def GetDetach(self):
        return _znc_core.CSListener_GetDetach(self)

    def GetPort(self):
        return _znc_core.CSListener_GetPort(self)

    def GetSockName(self):
        return _znc_core.CSListener_GetSockName(self)

    def GetBindHost(self):
        return _znc_core.CSListener_GetBindHost(self)

    def GetIsSSL(self):
        return _znc_core.CSListener_GetIsSSL(self)

    def GetMaxConns(self):
        return _znc_core.CSListener_GetMaxConns(self)

    def GetTimeout(self):
        return _znc_core.CSListener_GetTimeout(self)

    def GetAFRequire(self):
        return _znc_core.CSListener_GetAFRequire(self)

    def SetPort(self, iPort):
        return _znc_core.CSListener_SetPort(self, iPort)

    def SetSockName(self, sSockName):
        return _znc_core.CSListener_SetSockName(self, sSockName)

    def SetBindHost(self, sBindHost):
        return _znc_core.CSListener_SetBindHost(self, sBindHost)

    def SetIsSSL(self, b):
        return _znc_core.CSListener_SetIsSSL(self, b)

    def SetMaxConns(self, i):
        return _znc_core.CSListener_SetMaxConns(self, i)

    def SetTimeout(self, i):
        return _znc_core.CSListener_SetTimeout(self, i)

    def SetAFRequire(self, iAFRequire):
        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):
        return _znc_core.CSocketManager_clear(self)

    def Cleanup(self):
        return _znc_core.CSocketManager_Cleanup(self)

    def GetSockObj(self, sHostname, uPort, iTimeout=60):
        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, pcSock=None):
        return _znc_core.CSocketManager_Connect(self, cCon, pcSock)

    def Listen(self, cListen, pcSock=None, piRandPort=None):
        return _znc_core.CSocketManager_Listen(self, cListen, pcSock, piRandPort)

    def HasFDs(self):
        return _znc_core.CSocketManager_HasFDs(self)

    def Loop(self):
        return _znc_core.CSocketManager_Loop(self)

    def DynamicSelectLoop(self, iLowerBounds, iUpperBounds, iMaxResolution=3600):
        return _znc_core.CSocketManager_DynamicSelectLoop(self, iLowerBounds, iUpperBounds, iMaxResolution)

    def AddSock(self, pcSock, sSockName):
        return _znc_core.CSocketManager_AddSock(self, pcSock, sSockName)

    def FindSockByRemotePort(self, iPort):
        return _znc_core.CSocketManager_FindSockByRemotePort(self, iPort)

    def FindSockByLocalPort(self, iPort):
        return _znc_core.CSocketManager_FindSockByLocalPort(self, iPort)

    def FindSockByName(self, sName):
        return _znc_core.CSocketManager_FindSockByName(self, sName)

    def FindSockByFD(self, iFD):
        return _znc_core.CSocketManager_FindSockByFD(self, iFD)

    def FindSocksByName(self, sName):
        return _znc_core.CSocketManager_FindSocksByName(self, sName)

    def FindSocksByRemoteHost(self, sHostname):
        return _znc_core.CSocketManager_FindSocksByRemoteHost(self, sHostname)

    def GetErrno(self):
        return _znc_core.CSocketManager_GetErrno(self)

    def GetSelectTimeout(self):
        return _znc_core.CSocketManager_GetSelectTimeout(self)

    def SetSelectTimeout(self, iTimeout):
        return _znc_core.CSocketManager_SetSelectTimeout(self, iTimeout)

    def DelSockByAddr(self, pcSock):
        return _znc_core.CSocketManager_DelSockByAddr(self, pcSock)

    def DelSock(self, iPos):
        return _znc_core.CSocketManager_DelSock(self, iPos)

    def SwapSockByIdx(self, pNewSock, iOrginalSockIdx):
        return _znc_core.CSocketManager_SwapSockByIdx(self, pNewSock, iOrginalSockIdx)

    def SwapSockByAddr(self, pNewSock, pOrigSock):
        return _znc_core.CSocketManager_SwapSockByAddr(self, pNewSock, pOrigSock)

    def GetBytesRead(self):
        return _znc_core.CSocketManager_GetBytesRead(self)

    def GetBytesWritten(self):
        return _znc_core.CSocketManager_GetBytesWritten(self)
    ECT_Read = _znc_core.CSocketManager_ECT_Read
    ECT_Write = _znc_core.CSocketManager_ECT_Write

    def FDSetCheck(self, iFd, miiReadyFds, eType):
        return _znc_core.CSocketManager_FDSetCheck(self, iFd, miiReadyFds, eType)

    def FDHasCheck(self, iFd, miiReadyFds, eType):
        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, uPort, iTimeout=60):
        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, iAddrLen, sIP, piPort):
        return _znc_core.CZNCSock_ConvertAddress(self, pAddr, iAddrLen, sIP, piPort)

    def GetSSLPeerFingerprint(self):
        return _znc_core.CZNCSock_GetSSLPeerFingerprint(self)

    def SetHostToVerifySSL(self, sHost):
        return _znc_core.CZNCSock_SetHostToVerifySSL(self, sHost)

    def SetSSLTrustedPeerFingerprints(self, ssFPs):
        return _znc_core.CZNCSock_SetSSLTrustedPeerFingerprints(self, ssFPs)

    def SetTrustAllCerts(self, bTrustAll):
        return _znc_core.CZNCSock_SetTrustAllCerts(self, bTrustAll)

    def GetTrustAllCerts(self):
        return _znc_core.CZNCSock_GetTrustAllCerts(self)

    def SetTrustPKI(self, bTrustPKI):
        return _znc_core.CZNCSock_SetTrustPKI(self, bTrustPKI)

    def GetTrustPKI(self):
        return _znc_core.CZNCSock_GetTrustPKI(self)

    def SetEncoding(self, arg2):
        return _znc_core.CZNCSock_SetEncoding(self, arg2)

    def GetRemoteIP(self):
        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):
        return _znc_core.CSockManager_ListenHost(self, *args)

    def ListenAll(self, *args):
        return _znc_core.CSockManager_ListenAll(self, *args)

    def ListenRand(self, *args):
        return _znc_core.CSockManager_ListenRand(self, *args)

    def ListenAllRand(self, *args):
        return _znc_core.CSockManager_ListenAllRand(self, *args)

    def Connect(self, *args):
        return _znc_core.CSockManager_Connect(self, *args)

    def GetAnonConnectionCount(self, sIP):
        return _znc_core.CSockManager_GetAnonConnectionCount(self, sIP)

    def DelSockByAddr(self, pcSock):
        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):
        return _znc_core.CSocket_ReachedMaxBuffer(self)

    def SockError(self, iErrno, sDescription):
        return _znc_core.CSocket_SockError(self, iErrno, sDescription)

    def ConnectionFrom(self, sHost, uPort):
        return _znc_core.CSocket_ConnectionFrom(self, sHost, uPort)

    def Connect(self, *args):
        return _znc_core.CSocket_Connect(self, *args)

    def Listen(self, *args):
        return _znc_core.CSocket_Listen(self, *args)

    def GetModule(self):
        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):
        return _znc_core.CFile_SetFileName(self, sLongName)

    def IsReg(self, *args):
        return _znc_core.CFile_IsReg(self, *args)

    def IsDir(self, *args):
        return _znc_core.CFile_IsDir(self, *args)

    def IsChr(self, *args):
        return _znc_core.CFile_IsChr(self, *args)

    def IsBlk(self, *args):
        return _znc_core.CFile_IsBlk(self, *args)

    def IsFifo(self, *args):
        return _znc_core.CFile_IsFifo(self, *args)

    def IsLnk(self, *args):
        return _znc_core.CFile_IsLnk(self, *args)

    def IsSock(self, *args):
        return _znc_core.CFile_IsSock(self, *args)

    @staticmethod
    def FType(sFileName, eType, bUseLstat=False):
        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):
        return _znc_core.CFile_Exists(*args)

    @staticmethod
    def GetSize(*args):
        return _znc_core.CFile_GetSize(*args)

    @staticmethod
    def GetATime(*args):
        return _znc_core.CFile_GetATime(*args)

    @staticmethod
    def GetMTime(*args):
        return _znc_core.CFile_GetMTime(*args)

    @staticmethod
    def GetCTime(*args):
        return _znc_core.CFile_GetCTime(*args)

    @staticmethod
    def GetUID(*args):
        return _znc_core.CFile_GetUID(*args)

    @staticmethod
    def GetGID(*args):
        return _znc_core.CFile_GetGID(*args)

    @staticmethod
    def GetInfo(sFile, st):
        return _znc_core.CFile_GetInfo(sFile, st)

    @staticmethod
    def Delete(*args):
        return _znc_core.CFile_Delete(*args)

    @staticmethod
    def Move(*args):
        return _znc_core.CFile_Move(*args)

    @staticmethod
    def Copy(*args):
        return _znc_core.CFile_Copy(*args)

    @staticmethod
    def Chmod(*args):
        return _znc_core.CFile_Chmod(*args)

    def Seek(self, uPos):
        return _znc_core.CFile_Seek(self, uPos)

    def Truncate(self):
        return _znc_core.CFile_Truncate(self)

    def Sync(self):
        return _znc_core.CFile_Sync(self)

    def Open(self, *args):
        return _znc_core.CFile_Open(self, *args)

    def Read(self, pszBuffer, iBytes):
        return _znc_core.CFile_Read(self, pszBuffer, iBytes)

    def ReadLine(self, *args):
        return _znc_core.CFile_ReadLine(self, *args)

    def ReadFile(self, *args):
        return _znc_core.CFile_ReadFile(self, *args)

    def Write(self, *args):
        return _znc_core.CFile_Write(self, *args)

    def Close(self):
        return _znc_core.CFile_Close(self)

    def ClearBuffer(self):
        return _znc_core.CFile_ClearBuffer(self)

    def TryExLock(self, *args):
        return _znc_core.CFile_TryExLock(self, *args)

    def ExLock(self):
        return _znc_core.CFile_ExLock(self)

    def UnLock(self):
        return _znc_core.CFile_UnLock(self)

    def IsOpen(self):
        return _znc_core.CFile_IsOpen(self)

    def GetLongName(self):
        return _znc_core.CFile_GetLongName(self)

    def GetShortName(self):
        return _znc_core.CFile_GetShortName(self)

    def GetDir(self):
        return _znc_core.CFile_GetDir(self)

    def HadError(self):
        return _znc_core.CFile_HadError(self)

    def ResetError(self):
        return _znc_core.CFile_ResetError(self)

    @staticmethod
    def InitHomePath(sFallback):
        return _znc_core.CFile_InitHomePath(sFallback)

    @staticmethod
    def GetHomePath():
        return _znc_core.CFile_GetHomePath()

# Register CFile in _znc_core:
_znc_core.CFile_swigregister(CFile)
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):
        return _znc_core.CDir_CleanUp(self)

    def Fill(self, sDir):
        return _znc_core.CDir_Fill(self, sDir)

    def FillByWildcard(self, sDir, sWildcard):
        return _znc_core.CDir_FillByWildcard(self, sDir, sWildcard)

    def Chmod(self, *args):
        return _znc_core.CDir_Chmod(self, *args)

    def Delete(self, *args):
        return _znc_core.CDir_Delete(self, *args)

    def GetSortAttr(self):
        return _znc_core.CDir_GetSortAttr(self)

    def IsDescending(self):
        return _znc_core.CDir_IsDescending(self)

    @staticmethod
    def CheckPathPrefix(*args):
        return _znc_core.CDir_CheckPathPrefix(*args)

    @staticmethod
    def ChangeDir(*args):
        return _znc_core.CDir_ChangeDir(*args)

    @staticmethod
    def MakeDir(sPath, iMode=int("0700", 8)):
        return _znc_core.CDir_MakeDir(sPath, iMode)

    @staticmethod
    def GetCWD():
        return _znc_core.CDir_GetCWD()

# Register CDir in _znc_core:
_znc_core.CDir_swigregister(CDir)
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):
        return _znc_core.CMessage_GetType(self)

    def Equals(self, Other):
        return _znc_core.CMessage_Equals(self, Other)

    def Clone(self, Other):
        return _znc_core.CMessage_Clone(self, Other)

    def GetNetwork(self):
        return _znc_core.CMessage_GetNetwork(self)

    def SetNetwork(self, pNetwork):
        return _znc_core.CMessage_SetNetwork(self, pNetwork)

    def GetClient(self):
        return _znc_core.CMessage_GetClient(self)

    def SetClient(self, pClient):
        return _znc_core.CMessage_SetClient(self, pClient)

    def GetChan(self):
        return _znc_core.CMessage_GetChan(self)

    def SetChan(self, pChan):
        return _znc_core.CMessage_SetChan(self, pChan)

    def GetNick(self, *args):
        return _znc_core.CMessage_GetNick(self, *args)

    def SetNick(self, Nick):
        return _znc_core.CMessage_SetNick(self, Nick)

    def GetCommand(self):
        return _znc_core.CMessage_GetCommand(self)

    def SetCommand(self, sCommand):
        return _znc_core.CMessage_SetCommand(self, sCommand)

    def GetParamsSplit(self, uIdx, uLen=-1):
        return _znc_core.CMessage_GetParamsSplit(self, uIdx, uLen)

    def SetParams(self, vsParams):
        return _znc_core.CMessage_SetParams(self, vsParams)

    def GetParams(self, *args):
        return _znc_core.CMessage_GetParams(self, *args)

    def GetParamsColon(self, uIdx, uLen=-1):
        return _znc_core.CMessage_GetParamsColon(self, uIdx, uLen)

    def GetParam(self, uIdx):
        return _znc_core.CMessage_GetParam(self, uIdx)

    def SetParam(self, uIdx, sParam):
        return _znc_core.CMessage_SetParam(self, uIdx, sParam)

    def GetTime(self):
        return _znc_core.CMessage_GetTime(self)

    def SetTime(self, ts):
        return _znc_core.CMessage_SetTime(self, ts)

    def GetTags(self):
        return _znc_core.CMessage_GetTags(self)

    def SetTags(self, mssTags):
        return _znc_core.CMessage_SetTags(self, mssTags)

    def GetTag(self, sKey):
        return _znc_core.CMessage_GetTag(self, sKey)

    def SetTag(self, sKey, sValue):
        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):
        return _znc_core.CMessage_ToString(self, *args)

    def Parse(self, sMessage):
        return _znc_core.CMessage_Parse(self, sMessage)

    def As_CTargetMessage(self):
        return _znc_core.CMessage_As_CTargetMessage(self)

    def As_CActionMessage(self):
        return _znc_core.CMessage_As_CActionMessage(self)

    def As_CCTCPMessage(self):
        return _znc_core.CMessage_As_CCTCPMessage(self)

    def As_CJoinMessage(self):
        return _znc_core.CMessage_As_CJoinMessage(self)

    def As_CModeMessage(self):
        return _znc_core.CMessage_As_CModeMessage(self)

    def As_CNickMessage(self):
        return _znc_core.CMessage_As_CNickMessage(self)

    def As_CNoticeMessage(self):
        return _znc_core.CMessage_As_CNoticeMessage(self)

    def As_CNumericMessage(self):
        return _znc_core.CMessage_As_CNumericMessage(self)

    def As_CKickMessage(self):
        return _znc_core.CMessage_As_CKickMessage(self)

    def As_CPartMessage(self):
        return _znc_core.CMessage_As_CPartMessage(self)

    def As_CQuitMessage(self):
        return _znc_core.CMessage_As_CQuitMessage(self)

    def As_CTextMessage(self):
        return _znc_core.CMessage_As_CTextMessage(self)

    def As_CTopicMessage(self):
        return _znc_core.CMessage_As_CTopicMessage(self)

    def __str__(self):
        return _znc_core.CMessage___str__(self)

    def __repr__(self):
        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):
        return _znc_core.CTargetMessage_GetTarget(self)

    def SetTarget(self, sTarget):
        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):
        return _znc_core.CActionMessage_GetText(self)

    def SetText(self, sText):
        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):
        return _znc_core.CCTCPMessage_IsReply(self)

    def GetText(self):
        return _znc_core.CCTCPMessage_GetText(self)

    def SetText(self, sText):
        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):
        return _znc_core.CJoinMessage_GetKey(self)

    def SetKey(self, sKey):
        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):
        return _znc_core.CModeMessage_GetModes(self)

    def GetModeList(self):
        return _znc_core.CModeMessage_GetModeList(self)

    def GetModeParams(self):
        return _znc_core.CModeMessage_GetModeParams(self)

    def HasModes(self):
        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):
        return _znc_core.CNickMessage_GetOldNick(self)

    def GetNewNick(self):
        return _znc_core.CNickMessage_GetNewNick(self)

    def SetNewNick(self, sNick):
        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):
        return _znc_core.CNoticeMessage_GetText(self)

    def SetText(self, sText):
        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):
        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):
        return _znc_core.CKickMessage_GetKickedNick(self)

    def SetKickedNick(self, sNick):
        return _znc_core.CKickMessage_SetKickedNick(self, sNick)

    def GetReason(self):
        return _znc_core.CKickMessage_GetReason(self)

    def SetReason(self, sReason):
        return _znc_core.CKickMessage_SetReason(self, sReason)

    def GetText(self):
        return _znc_core.CKickMessage_GetText(self)

    def SetText(self, sText):
        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):
        return _znc_core.CPartMessage_GetReason(self)

    def SetReason(self, sReason):
        return _znc_core.CPartMessage_SetReason(self, sReason)

    def GetText(self):
        return _znc_core.CPartMessage_GetText(self)

    def SetText(self, sText):
        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):
        return _znc_core.CQuitMessage_GetReason(self)

    def SetReason(self, sReason):
        return _znc_core.CQuitMessage_SetReason(self, sReason)

    def GetText(self):
        return _znc_core.CQuitMessage_GetText(self)

    def SetText(self, sText):
        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):
        return _znc_core.CTextMessage_GetText(self)

    def SetText(self, sText):
        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):
        return _znc_core.CTopicMessage_GetTopic(self)

    def SetTopic(self, sTopic):
        return _znc_core.CTopicMessage_SetTopic(self, sTopic)

    def GetText(self):
        return _znc_core.CTopicMessage_GetText(self)

    def SetText(self, sText):
        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 CCapability(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_CCapability

    def OnServerChangedSupport(self, pNetwork, bState):
        return _znc_core.CCapability_OnServerChangedSupport(self, pNetwork, bState)

    def OnClientChangedSupport(self, pClient, bState):
        return _znc_core.CCapability_OnClientChangedSupport(self, pClient, bState)

    def GetModule(self):
        return _znc_core.CCapability_GetModule(self)

    def SetModule(self, p):
        return _znc_core.CCapability_SetModule(self, p)

    def __init__(self):
        _znc_core.CCapability_swiginit(self, _znc_core.new_CCapability())

# Register CCapability in _znc_core:
_znc_core.CCapability_swigregister(CCapability)
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, uInterval, uCycles, sLabel, sDescription):
        _znc_core.CTimer_swiginit(self, _znc_core.new_CTimer(pModule, uInterval, uCycles, sLabel, sDescription))
    __swig_destroy__ = _znc_core.delete_CTimer

    def SetModule(self, p):
        return _znc_core.CTimer_SetModule(self, p)

    def SetDescription(self, s):
        return _znc_core.CTimer_SetDescription(self, s)

    def GetModule(self):
        return _znc_core.CTimer_GetModule(self)

    def GetDescription(self):
        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, uInterval, uCycles, sLabel, sDescription):
        _znc_core.CFPTimer_swiginit(self, _znc_core.new_CFPTimer(pModule, uInterval, uCycles, sLabel, sDescription))
    __swig_destroy__ = _znc_core.delete_CFPTimer

    def SetFPCallback(self, p):
        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):
        return _znc_core.CModInfo___lt__(self, Info)

    def SupportsType(self, eType):
        return _znc_core.CModInfo_SupportsType(self, eType)

    def AddType(self, eType):
        return _znc_core.CModInfo_AddType(self, eType)

    @staticmethod
    def ModuleTypeToString(eType):
        return _znc_core.CModInfo_ModuleTypeToString(eType)

    def GetName(self):
        return _znc_core.CModInfo_GetName(self)

    def GetPath(self):
        return _znc_core.CModInfo_GetPath(self)

    def GetDescription(self):
        return _znc_core.CModInfo_GetDescription(self)

    def GetWikiPage(self):
        return _znc_core.CModInfo_GetWikiPage(self)

    def GetArgsHelpText(self):
        return _znc_core.CModInfo_GetArgsHelpText(self)

    def GetHasArgs(self):
        return _znc_core.CModInfo_GetHasArgs(self)

    def GetLoader(self):
        return _znc_core.CModInfo_GetLoader(self)

    def GetDefaultType(self):
        return _znc_core.CModInfo_GetDefaultType(self)

    def SetName(self, s):
        return _znc_core.CModInfo_SetName(self, s)

    def SetPath(self, s):
        return _znc_core.CModInfo_SetPath(self, s)

    def SetDescription(self, s):
        return _znc_core.CModInfo_SetDescription(self, s)

    def SetWikiPage(self, s):
        return _znc_core.CModInfo_SetWikiPage(self, s)

    def SetArgsHelpText(self, s):
        return _znc_core.CModInfo_SetArgsHelpText(self, s)

    def SetHasArgs(self, b=False):
        return _znc_core.CModInfo_SetHasArgs(self, b)

    def SetLoader(self, fLoader):
        return _znc_core.CModInfo_SetLoader(self, fLoader)

    def SetDefaultType(self, eType):
        return _znc_core.CModInfo_SetDefaultType(self, eType)

    def t_s(self, *args):
        return _znc_core.CModInfo_t_s(self, *args)

# Register CModInfo in _znc_core:
_znc_core.CModInfo_swigregister(CModInfo)
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):
        return _znc_core.CModCommand_InitHelp(Table)

    def AddHelp(self, Table):
        return _znc_core.CModCommand_AddHelp(self, Table)

    def GetCommand(self):
        return _znc_core.CModCommand_GetCommand(self)

    def GetFunction(self):
        return _znc_core.CModCommand_GetFunction(self)

    def GetArgs(self):
        return _znc_core.CModCommand_GetArgs(self)

    def GetDescription(self):
        return _znc_core.CModCommand_GetDescription(self)

    def Call(self, sLine):
        return _znc_core.CModCommand_Call(self, sLine)
    __swig_destroy__ = _znc_core.delete_CModCommand

# Register CModCommand in _znc_core:
_znc_core.CModCommand_swigregister(CModCommand)
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):
        return _znc_core.CModule_SetUser(self, pUser)

    def SetNetwork(self, pNetwork):
        return _znc_core.CModule_SetNetwork(self, pNetwork)

    def SetClient(self, pClient):
        return _znc_core.CModule_SetClient(self, pClient)

    def Unload(self):
        return _znc_core.CModule_Unload(self)

    def OnLoad(self, sArgsi, sMessage):
        return _znc_core.CModule_OnLoad(self, sArgsi, sMessage)

    def OnBoot(self):
        return _znc_core.CModule_OnBoot(self)

    def WebRequiresLogin(self):
        return _znc_core.CModule_WebRequiresLogin(self)

    def WebRequiresAdmin(self):
        return _znc_core.CModule_WebRequiresAdmin(self)

    def GetWebMenuTitle(self):
        return _znc_core.CModule_GetWebMenuTitle(self)

    def GetWebPath(self):
        return _znc_core.CModule_GetWebPath(self)

    def GetWebFilesPath(self):
        return _znc_core.CModule_GetWebFilesPath(self)

    def OnWebPreRequest(self, WebSock, sPageName):
        return _znc_core.CModule_OnWebPreRequest(self, WebSock, sPageName)

    def OnWebRequest(self, WebSock, sPageName, Tmpl):
        return _znc_core.CModule_OnWebRequest(self, WebSock, sPageName, Tmpl)

    def ValidateWebRequestCSRFCheck(self, WebSock, sPageName):
        return _znc_core.CModule_ValidateWebRequestCSRFCheck(self, WebSock, sPageName)

    def AddSubPage(self, spSubPage):
        return _znc_core.CModule_AddSubPage(self, spSubPage)

    def ClearSubPages(self):
        return _znc_core.CModule_ClearSubPages(self)

    def GetSubPages(self):
        return _znc_core.CModule_GetSubPages(self)

    def OnEmbeddedWebRequest(self, WebSock, sPageName, Tmpl):
        return _znc_core.CModule_OnEmbeddedWebRequest(self, WebSock, sPageName, Tmpl)

    def OnPreRehash(self):
        return _znc_core.CModule_OnPreRehash(self)

    def OnPostRehash(self):
        return _znc_core.CModule_OnPostRehash(self)

    def OnIRCDisconnected(self):
        return _znc_core.CModule_OnIRCDisconnected(self)

    def OnIRCConnected(self):
        return _znc_core.CModule_OnIRCConnected(self)

    def OnIRCConnecting(self, pIRCSock):
        return _znc_core.CModule_OnIRCConnecting(self, pIRCSock)

    def OnIRCConnectionError(self, pIRCSock):
        return _znc_core.CModule_OnIRCConnectionError(self, pIRCSock)

    def OnIRCRegistration(self, sPass, sNick, sIdent, sRealName):
        return _znc_core.CModule_OnIRCRegistration(self, sPass, sNick, sIdent, sRealName)

    def OnBroadcast(self, sMessage):
        return _znc_core.CModule_OnBroadcast(self, sMessage)

    def OnChanPermission3(self, pOpNick, Nick, Channel, cMode, bAdded, bNoChange):
        return _znc_core.CModule_OnChanPermission3(self, pOpNick, Nick, Channel, cMode, bAdded, bNoChange)

    def OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange):
        return _znc_core.CModule_OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnChanPermission(self, OpNick, Nick, Channel, uMode, bAdded, bNoChange):
        return _znc_core.CModule_OnChanPermission(self, OpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnOp2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CModule_OnOp2(self, pOpNick, Nick, Channel, bNoChange)

    def OnOp(self, OpNick, Nick, Channel, bNoChange):
        return _znc_core.CModule_OnOp(self, OpNick, Nick, Channel, bNoChange)

    def OnDeop2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CModule_OnDeop2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDeop(self, OpNick, Nick, Channel, bNoChange):
        return _znc_core.CModule_OnDeop(self, OpNick, Nick, Channel, bNoChange)

    def OnVoice2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CModule_OnVoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnVoice(self, OpNick, Nick, Channel, bNoChange):
        return _znc_core.CModule_OnVoice(self, OpNick, Nick, Channel, bNoChange)

    def OnDevoice2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CModule_OnDevoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDevoice(self, OpNick, Nick, Channel, bNoChange):
        return _znc_core.CModule_OnDevoice(self, OpNick, Nick, Channel, bNoChange)

    def OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange):
        return _znc_core.CModule_OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnMode(self, OpNick, Channel, uMode, sArg, bAdded, bNoChange):
        return _znc_core.CModule_OnMode(self, OpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnRawMode2(self, pOpNick, Channel, sModes, sArgs):
        return _znc_core.CModule_OnRawMode2(self, pOpNick, Channel, sModes, sArgs)

    def OnRawMode(self, OpNick, Channel, sModes, sArgs):
        return _znc_core.CModule_OnRawMode(self, OpNick, Channel, sModes, sArgs)

    def OnRaw(self, sLine):
        return _znc_core.CModule_OnRaw(self, sLine)

    def OnRawMessage(self, Message):
        return _znc_core.CModule_OnRawMessage(self, Message)

    def OnNumericMessage(self, Message):
        return _znc_core.CModule_OnNumericMessage(self, Message)

    def OnStatusCommand(self, sCommand):
        return _znc_core.CModule_OnStatusCommand(self, sCommand)

    def OnModCommand(self, sCommand):
        return _znc_core.CModule_OnModCommand(self, sCommand)

    def OnUnknownModCommand(self, sCommand):
        return _znc_core.CModule_OnUnknownModCommand(self, sCommand)

    def OnModNotice(self, sMessage):
        return _znc_core.CModule_OnModNotice(self, sMessage)

    def OnModCTCP(self, sMessage):
        return _znc_core.CModule_OnModCTCP(self, sMessage)

    def OnQuitMessage(self, Message, vChans):
        return _znc_core.CModule_OnQuitMessage(self, Message, vChans)

    def OnQuit(self, Nick, sMessage, vChans):
        return _znc_core.CModule_OnQuit(self, Nick, sMessage, vChans)

    def OnNickMessage(self, Message, vChans):
        return _znc_core.CModule_OnNickMessage(self, Message, vChans)

    def OnNick(self, Nick, sNewNick, vChans):
        return _znc_core.CModule_OnNick(self, Nick, sNewNick, vChans)

    def OnKickMessage(self, Message):
        return _znc_core.CModule_OnKickMessage(self, Message)

    def OnKick(self, OpNick, sKickedNick, Channel, sMessage):
        return _znc_core.CModule_OnKick(self, OpNick, sKickedNick, Channel, sMessage)

    def OnJoining(self, Channel):
        return _znc_core.CModule_OnJoining(self, Channel)

    def OnJoinMessage(self, Message):
        return _znc_core.CModule_OnJoinMessage(self, Message)

    def OnJoin(self, Nick, Channel):
        return _znc_core.CModule_OnJoin(self, Nick, Channel)

    def OnPartMessage(self, Message):
        return _znc_core.CModule_OnPartMessage(self, Message)

    def OnPart(self, Nick, Channel, sMessage):
        return _znc_core.CModule_OnPart(self, Nick, Channel, sMessage)

    def OnInvite(self, Nick, sChan):
        return _znc_core.CModule_OnInvite(self, Nick, sChan)

    def OnChanBufferStarting(self, Chan, Client):
        return _znc_core.CModule_OnChanBufferStarting(self, Chan, Client)

    def OnChanBufferEnding(self, Chan, Client):
        return _znc_core.CModule_OnChanBufferEnding(self, Chan, Client)

    def OnChanBufferPlayMessage(self, Message):
        return _znc_core.CModule_OnChanBufferPlayMessage(self, Message)

    def OnChanBufferPlayLine2(self, Chan, Client, sLine, tv):
        return _znc_core.CModule_OnChanBufferPlayLine2(self, Chan, Client, sLine, tv)

    def OnChanBufferPlayLine(self, Chan, Client, sLine):
        return _znc_core.CModule_OnChanBufferPlayLine(self, Chan, Client, sLine)

    def OnPrivBufferStarting(self, Query, Client):
        return _znc_core.CModule_OnPrivBufferStarting(self, Query, Client)

    def OnPrivBufferEnding(self, Query, Client):
        return _znc_core.CModule_OnPrivBufferEnding(self, Query, Client)

    def OnPrivBufferPlayMessage(self, Message):
        return _znc_core.CModule_OnPrivBufferPlayMessage(self, Message)

    def OnPrivBufferPlayLine2(self, Client, sLine, tv):
        return _znc_core.CModule_OnPrivBufferPlayLine2(self, Client, sLine, tv)

    def OnPrivBufferPlayLine(self, Client, sLine):
        return _znc_core.CModule_OnPrivBufferPlayLine(self, Client, sLine)

    def OnClientLogin(self):
        return _znc_core.CModule_OnClientLogin(self)

    def OnClientDisconnect(self):
        return _znc_core.CModule_OnClientDisconnect(self)

    def OnUserRaw(self, sLine):
        return _znc_core.CModule_OnUserRaw(self, sLine)

    def OnUserRawMessage(self, Message):
        return _znc_core.CModule_OnUserRawMessage(self, Message)

    def OnUserCTCPReplyMessage(self, Message):
        return _znc_core.CModule_OnUserCTCPReplyMessage(self, Message)

    def OnUserCTCPReply(self, sTarget, sMessage):
        return _znc_core.CModule_OnUserCTCPReply(self, sTarget, sMessage)

    def OnUserCTCPMessage(self, Message):
        return _znc_core.CModule_OnUserCTCPMessage(self, Message)

    def OnUserCTCP(self, sTarget, sMessage):
        return _znc_core.CModule_OnUserCTCP(self, sTarget, sMessage)

    def OnUserActionMessage(self, Message):
        return _znc_core.CModule_OnUserActionMessage(self, Message)

    def OnUserAction(self, sTarget, sMessage):
        return _znc_core.CModule_OnUserAction(self, sTarget, sMessage)

    def OnUserTextMessage(self, Message):
        return _znc_core.CModule_OnUserTextMessage(self, Message)

    def OnUserMsg(self, sTarget, sMessage):
        return _znc_core.CModule_OnUserMsg(self, sTarget, sMessage)

    def OnUserNoticeMessage(self, Message):
        return _znc_core.CModule_OnUserNoticeMessage(self, Message)

    def OnUserNotice(self, sTarget, sMessage):
        return _znc_core.CModule_OnUserNotice(self, sTarget, sMessage)

    def OnUserJoinMessage(self, Message):
        return _znc_core.CModule_OnUserJoinMessage(self, Message)

    def OnUserJoin(self, sChannel, sKey):
        return _znc_core.CModule_OnUserJoin(self, sChannel, sKey)

    def OnUserPartMessage(self, Message):
        return _znc_core.CModule_OnUserPartMessage(self, Message)

    def OnUserPart(self, sChannel, sMessage):
        return _znc_core.CModule_OnUserPart(self, sChannel, sMessage)

    def OnUserTopicMessage(self, Message):
        return _znc_core.CModule_OnUserTopicMessage(self, Message)

    def OnUserTopic(self, sChannel, sTopic):
        return _znc_core.CModule_OnUserTopic(self, sChannel, sTopic)

    def OnUserTopicRequest(self, sChannel):
        return _znc_core.CModule_OnUserTopicRequest(self, sChannel)

    def OnUserQuitMessage(self, Message):
        return _znc_core.CModule_OnUserQuitMessage(self, Message)

    def OnUserQuit(self, sMessage):
        return _znc_core.CModule_OnUserQuit(self, sMessage)

    def OnCTCPReplyMessage(self, Message):
        return _znc_core.CModule_OnCTCPReplyMessage(self, Message)

    def OnCTCPReply(self, Nick, sMessage):
        return _znc_core.CModule_OnCTCPReply(self, Nick, sMessage)

    def OnPrivCTCPMessage(self, Message):
        return _znc_core.CModule_OnPrivCTCPMessage(self, Message)

    def OnPrivCTCP(self, Nick, sMessage):
        return _znc_core.CModule_OnPrivCTCP(self, Nick, sMessage)

    def OnChanCTCPMessage(self, Message):
        return _znc_core.CModule_OnChanCTCPMessage(self, Message)

    def OnChanCTCP(self, Nick, Channel, sMessage):
        return _znc_core.CModule_OnChanCTCP(self, Nick, Channel, sMessage)

    def OnPrivActionMessage(self, Message):
        return _znc_core.CModule_OnPrivActionMessage(self, Message)

    def OnPrivAction(self, Nick, sMessage):
        return _znc_core.CModule_OnPrivAction(self, Nick, sMessage)

    def OnChanActionMessage(self, Message):
        return _znc_core.CModule_OnChanActionMessage(self, Message)

    def OnChanAction(self, Nick, Channel, sMessage):
        return _znc_core.CModule_OnChanAction(self, Nick, Channel, sMessage)

    def OnPrivTextMessage(self, Message):
        return _znc_core.CModule_OnPrivTextMessage(self, Message)

    def OnPrivMsg(self, Nick, sMessage):
        return _znc_core.CModule_OnPrivMsg(self, Nick, sMessage)

    def OnChanTextMessage(self, Message):
        return _znc_core.CModule_OnChanTextMessage(self, Message)

    def OnChanMsg(self, Nick, Channel, sMessage):
        return _znc_core.CModule_OnChanMsg(self, Nick, Channel, sMessage)

    def OnPrivNoticeMessage(self, Message):
        return _znc_core.CModule_OnPrivNoticeMessage(self, Message)

    def OnPrivNotice(self, Nick, sMessage):
        return _znc_core.CModule_OnPrivNotice(self, Nick, sMessage)

    def OnChanNoticeMessage(self, Message):
        return _znc_core.CModule_OnChanNoticeMessage(self, Message)

    def OnChanNotice(self, Nick, Channel, sMessage):
        return _znc_core.CModule_OnChanNotice(self, Nick, Channel, sMessage)

    def OnTopicMessage(self, Message):
        return _znc_core.CModule_OnTopicMessage(self, Message)

    def OnTopic(self, Nick, Channel, sTopic):
        return _znc_core.CModule_OnTopic(self, Nick, Channel, sTopic)

    def OnServerCapAvailable(self, sCap):
        return _znc_core.CModule_OnServerCapAvailable(self, sCap)

    def OnServerCap302Available(self, sCap, sValue):
        return _znc_core.CModule_OnServerCap302Available(self, sCap, sValue)

    def OnServerCapResult(self, sCap, bSuccess):
        return _znc_core.CModule_OnServerCapResult(self, sCap, bSuccess)

    def OnTimerAutoJoin(self, Channel):
        return _znc_core.CModule_OnTimerAutoJoin(self, Channel)

    def OnAddNetwork(self, Network, sErrorRet):
        return _znc_core.CModule_OnAddNetwork(self, Network, sErrorRet)

    def OnDeleteNetwork(self, Network):
        return _znc_core.CModule_OnDeleteNetwork(self, Network)

    def OnSendToClientMessage(self, Message):
        return _znc_core.CModule_OnSendToClientMessage(self, Message)

    def OnSendToClient(self, sLine, Client):
        return _znc_core.CModule_OnSendToClient(self, sLine, Client)

    def OnSendToIRCMessage(self, Message):
        return _znc_core.CModule_OnSendToIRCMessage(self, Message)

    def OnSendToIRC(self, sLine):
        return _znc_core.CModule_OnSendToIRC(self, sLine)

    def GetDLL(self):
        return _znc_core.CModule_GetDLL(self)

    def PutIRC(self, *args):
        return _znc_core.CModule_PutIRC(self, *args)

    def PutUser(self, sLine):
        return _znc_core.CModule_PutUser(self, sLine)

    def PutStatus(self, sLine):
        return _znc_core.CModule_PutStatus(self, sLine)

    def PutModule(self, *args):
        return _znc_core.CModule_PutModule(self, *args)

    def PutModNotice(self, sLine):
        return _znc_core.CModule_PutModNotice(self, sLine)

    def GetModName(self):
        return _znc_core.CModule_GetModName(self)

    def GetModNick(self):
        return _znc_core.CModule_GetModNick(self)

    def GetModDataDir(self):
        return _znc_core.CModule_GetModDataDir(self)

    def AddTimer(self, *args):
        return _znc_core.CModule_AddTimer(self, *args)

    def RemTimer(self, *args):
        return _znc_core.CModule_RemTimer(self, *args)

    def UnlinkTimer(self, pTimer):
        return _znc_core.CModule_UnlinkTimer(self, pTimer)

    def FindTimer(self, sLabel):
        return _znc_core.CModule_FindTimer(self, sLabel)

    def BeginTimers(self):
        return _znc_core.CModule_BeginTimers(self)

    def EndTimers(self):
        return _znc_core.CModule_EndTimers(self)

    def ListTimers(self):
        return _znc_core.CModule_ListTimers(self)

    def AddSocket(self, pSocket):
        return _znc_core.CModule_AddSocket(self, pSocket)

    def RemSocket(self, *args):
        return _znc_core.CModule_RemSocket(self, *args)

    def UnlinkSocket(self, pSocket):
        return _znc_core.CModule_UnlinkSocket(self, pSocket)

    def FindSocket(self, sSockName):
        return _znc_core.CModule_FindSocket(self, sSockName)

    def BeginSockets(self):
        return _znc_core.CModule_BeginSockets(self)

    def EndSockets(self):
        return _znc_core.CModule_EndSockets(self)

    def ListSockets(self):
        return _znc_core.CModule_ListSockets(self)

    def AddHelpCommand(self):
        return _znc_core.CModule_AddHelpCommand(self)

    def AddCommand(self, *args):
        return _znc_core.CModule_AddCommand(self, *args)

    def RemCommand(self, sCmd):
        return _znc_core.CModule_RemCommand(self, sCmd)

    def FindCommand(self, sCmd):
        return _znc_core.CModule_FindCommand(self, sCmd)

    def HandleCommand(self, sLine):
        return _znc_core.CModule_HandleCommand(self, sLine)

    def HandleHelpCommand(self, *args):
        return _znc_core.CModule_HandleHelpCommand(self, *args)

    def LoadRegistry(self):
        return _znc_core.CModule_LoadRegistry(self)

    def SaveRegistry(self):
        return _znc_core.CModule_SaveRegistry(self)

    def MoveRegistry(self, sPath):
        return _znc_core.CModule_MoveRegistry(self, sPath)

    def SetNV(self, sName, sValue, bWriteToDisk=True):
        return _znc_core.CModule_SetNV(self, sName, sValue, bWriteToDisk)

    def GetNV(self, sName):
        return _znc_core.CModule_GetNV(self, sName)

    def HasNV(self, sName):
        return _znc_core.CModule_HasNV(self, sName)

    def FindNV(self, sName):
        return _znc_core.CModule_FindNV(self, sName)

    def EndNV(self):
        return _znc_core.CModule_EndNV(self)

    def BeginNV(self):
        return _znc_core.CModule_BeginNV(self)

    def DelNV(self, *args):
        return _znc_core.CModule_DelNV(self, *args)

    def ClearNV(self, bWriteToDisk=True):
        return _znc_core.CModule_ClearNV(self, bWriteToDisk)

    def GetSavePath(self):
        return _znc_core.CModule_GetSavePath(self)

    def ExpandString(self, *args):
        return _znc_core.CModule_ExpandString(self, *args)

    def SetType(self, eType):
        return _znc_core.CModule_SetType(self, eType)

    def SetDescription(self, s):
        return _znc_core.CModule_SetDescription(self, s)

    def SetModPath(self, s):
        return _znc_core.CModule_SetModPath(self, s)

    def SetArgs(self, s):
        return _znc_core.CModule_SetArgs(self, s)

    def GetType(self):
        return _znc_core.CModule_GetType(self)

    def GetDescription(self):
        return _znc_core.CModule_GetDescription(self)

    def GetArgs(self):
        return _znc_core.CModule_GetArgs(self)

    def GetModPath(self):
        return _znc_core.CModule_GetModPath(self)

    def GetUser(self):
        return _znc_core.CModule_GetUser(self)

    def GetNetwork(self):
        return _znc_core.CModule_GetNetwork(self)

    def GetClient(self):
        return _znc_core.CModule_GetClient(self)

    def GetManager(self):
        return _znc_core.CModule_GetManager(self)

    def OnAddUser(self, User, sErrorRet):
        return _znc_core.CModule_OnAddUser(self, User, sErrorRet)

    def OnDeleteUser(self, User):
        return _znc_core.CModule_OnDeleteUser(self, User)

    def OnClientConnect(self, pSock, sHost, uPort):
        return _znc_core.CModule_OnClientConnect(self, pSock, sHost, uPort)

    def OnLoginAttempt(self, Auth):
        return _znc_core.CModule_OnLoginAttempt(self, Auth)

    def OnFailedLogin(self, sUsername, sRemoteIP):
        return _znc_core.CModule_OnFailedLogin(self, sUsername, sRemoteIP)

    def OnUnknownUserRaw(self, pClient, sLine):
        return _znc_core.CModule_OnUnknownUserRaw(self, pClient, sLine)

    def OnUnknownUserRawMessage(self, Message):
        return _znc_core.CModule_OnUnknownUserRawMessage(self, Message)

    def OnClientAttached(self):
        return _znc_core.CModule_OnClientAttached(self)

    def OnClientDetached(self):
        return _znc_core.CModule_OnClientDetached(self)

    def OnClientCapLs(self, pClient, ssCaps):
        return _znc_core.CModule_OnClientCapLs(self, pClient, ssCaps)

    def IsClientCapSupported(self, pClient, sCap, bState):
        return _znc_core.CModule_IsClientCapSupported(self, pClient, sCap, bState)

    def OnClientCapRequest(self, pClient, sCap, bState):
        return _znc_core.CModule_OnClientCapRequest(self, pClient, sCap, bState)

    def OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg):
        return _znc_core.CModule_OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg)

    def OnModuleUnloading(self, pModule, bSuccess, sRetMsg):
        return _znc_core.CModule_OnModuleUnloading(self, pModule, bSuccess, sRetMsg)

    def OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg):
        return _znc_core.CModule_OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg)

    def OnGetAvailableMods(self, ssMods, eType):
        return _znc_core.CModule_OnGetAvailableMods(self, ssMods, eType)

    def InternalServerDependentCapsOnServerCap302Available(self, sCap, sValue):
        return _znc_core.CModule_InternalServerDependentCapsOnServerCap302Available(self, sCap, sValue)

    def InternalServerDependentCapsOnServerCapResult(self, sCap, bSuccess):
        return _znc_core.CModule_InternalServerDependentCapsOnServerCapResult(self, sCap, bSuccess)

    def InternalServerDependentCapsOnClientCapLs(self, pClient, ssCaps):
        return _znc_core.CModule_InternalServerDependentCapsOnClientCapLs(self, pClient, ssCaps)

    def InternalServerDependentCapsIsClientCapSupported(self, pClient, sCap, bState):
        return _znc_core.CModule_InternalServerDependentCapsIsClientCapSupported(self, pClient, sCap, bState)

    def InternalServerDependentCapsOnClientCapRequest(self, pClient, sCap, bState):
        return _znc_core.CModule_InternalServerDependentCapsOnClientCapRequest(self, pClient, sCap, bState)

    def InternalServerDependentCapsOnClientAttached(self):
        return _znc_core.CModule_InternalServerDependentCapsOnClientAttached(self)

    def InternalServerDependentCapsOnClientDetached(self):
        return _znc_core.CModule_InternalServerDependentCapsOnClientDetached(self)

    def InternalServerDependentCapsOnIRCConnected(self):
        return _znc_core.CModule_InternalServerDependentCapsOnIRCConnected(self)

    def InternalServerDependentCapsOnIRCDisconnected(self):
        return _znc_core.CModule_InternalServerDependentCapsOnIRCDisconnected(self)

    def __str__(self):
        return _znc_core.CModule___str__(self)

    def BeginNV_(self):
        return _znc_core.CModule_BeginNV_(self)

    def ExistsNV(self, sName):
        return _znc_core.CModule_ExistsNV(self, sName)

    def AddServerDependentCapability(self, sName, serverCb, clientCb):
        return _znc_core.CModule_AddServerDependentCapability(self, sName, serverCb, clientCb)

# 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):
        return _znc_core.CModules_SetUser(self, pUser)

    def SetNetwork(self, pNetwork):
        return _znc_core.CModules_SetNetwork(self, pNetwork)

    def SetClient(self, pClient):
        return _znc_core.CModules_SetClient(self, pClient)

    def GetUser(self):
        return _znc_core.CModules_GetUser(self)

    def GetNetwork(self):
        return _znc_core.CModules_GetNetwork(self)

    def GetClient(self):
        return _znc_core.CModules_GetClient(self)

    def UnloadAll(self):
        return _znc_core.CModules_UnloadAll(self)

    def OnBoot(self):
        return _znc_core.CModules_OnBoot(self)

    def OnPreRehash(self):
        return _znc_core.CModules_OnPreRehash(self)

    def OnPostRehash(self):
        return _znc_core.CModules_OnPostRehash(self)

    def OnIRCDisconnected(self):
        return _znc_core.CModules_OnIRCDisconnected(self)

    def OnIRCConnected(self):
        return _znc_core.CModules_OnIRCConnected(self)

    def OnIRCConnecting(self, pIRCSock):
        return _znc_core.CModules_OnIRCConnecting(self, pIRCSock)

    def OnIRCConnectionError(self, pIRCSock):
        return _znc_core.CModules_OnIRCConnectionError(self, pIRCSock)

    def OnIRCRegistration(self, sPass, sNick, sIdent, sRealName):
        return _znc_core.CModules_OnIRCRegistration(self, sPass, sNick, sIdent, sRealName)

    def OnBroadcast(self, sMessage):
        return _znc_core.CModules_OnBroadcast(self, sMessage)

    def OnChanPermission3(self, pOpNick, Nick, Channel, cMode, bAdded, bNoChange):
        return _znc_core.CModules_OnChanPermission3(self, pOpNick, Nick, Channel, cMode, bAdded, bNoChange)

    def OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange):
        return _znc_core.CModules_OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnChanPermission(self, OpNick, Nick, Channel, uMode, bAdded, bNoChange):
        return _znc_core.CModules_OnChanPermission(self, OpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnOp2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CModules_OnOp2(self, pOpNick, Nick, Channel, bNoChange)

    def OnOp(self, OpNick, Nick, Channel, bNoChange):
        return _znc_core.CModules_OnOp(self, OpNick, Nick, Channel, bNoChange)

    def OnDeop2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CModules_OnDeop2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDeop(self, OpNick, Nick, Channel, bNoChange):
        return _znc_core.CModules_OnDeop(self, OpNick, Nick, Channel, bNoChange)

    def OnVoice2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CModules_OnVoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnVoice(self, OpNick, Nick, Channel, bNoChange):
        return _znc_core.CModules_OnVoice(self, OpNick, Nick, Channel, bNoChange)

    def OnDevoice2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CModules_OnDevoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDevoice(self, OpNick, Nick, Channel, bNoChange):
        return _znc_core.CModules_OnDevoice(self, OpNick, Nick, Channel, bNoChange)

    def OnRawMode2(self, pOpNick, Channel, sModes, sArgs):
        return _znc_core.CModules_OnRawMode2(self, pOpNick, Channel, sModes, sArgs)

    def OnRawMode(self, OpNick, Channel, sModes, sArgs):
        return _znc_core.CModules_OnRawMode(self, OpNick, Channel, sModes, sArgs)

    def OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange):
        return _znc_core.CModules_OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnMode(self, OpNick, Channel, uMode, sArg, bAdded, bNoChange):
        return _znc_core.CModules_OnMode(self, OpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnRaw(self, sLine):
        return _znc_core.CModules_OnRaw(self, sLine)

    def OnRawMessage(self, Message):
        return _znc_core.CModules_OnRawMessage(self, Message)

    def OnNumericMessage(self, Message):
        return _znc_core.CModules_OnNumericMessage(self, Message)

    def OnStatusCommand(self, sCommand):
        return _znc_core.CModules_OnStatusCommand(self, sCommand)

    def OnModCommand(self, sCommand):
        return _znc_core.CModules_OnModCommand(self, sCommand)

    def OnModNotice(self, sMessage):
        return _znc_core.CModules_OnModNotice(self, sMessage)

    def OnModCTCP(self, sMessage):
        return _znc_core.CModules_OnModCTCP(self, sMessage)

    def OnQuit(self, Nick, sMessage, vChans):
        return _znc_core.CModules_OnQuit(self, Nick, sMessage, vChans)

    def OnQuitMessage(self, Message, vChans):
        return _znc_core.CModules_OnQuitMessage(self, Message, vChans)

    def OnNick(self, Nick, sNewNick, vChans):
        return _znc_core.CModules_OnNick(self, Nick, sNewNick, vChans)

    def OnNickMessage(self, Message, vChans):
        return _znc_core.CModules_OnNickMessage(self, Message, vChans)

    def OnKick(self, Nick, sOpNick, Channel, sMessage):
        return _znc_core.CModules_OnKick(self, Nick, sOpNick, Channel, sMessage)

    def OnKickMessage(self, Message):
        return _znc_core.CModules_OnKickMessage(self, Message)

    def OnJoining(self, Channel):
        return _znc_core.CModules_OnJoining(self, Channel)

    def OnJoin(self, Nick, Channel):
        return _znc_core.CModules_OnJoin(self, Nick, Channel)

    def OnJoinMessage(self, Message):
        return _znc_core.CModules_OnJoinMessage(self, Message)

    def OnPart(self, Nick, Channel, sMessage):
        return _znc_core.CModules_OnPart(self, Nick, Channel, sMessage)

    def OnPartMessage(self, Message):
        return _znc_core.CModules_OnPartMessage(self, Message)

    def OnInvite(self, Nick, sChan):
        return _znc_core.CModules_OnInvite(self, Nick, sChan)

    def OnChanBufferStarting(self, Chan, Client):
        return _znc_core.CModules_OnChanBufferStarting(self, Chan, Client)

    def OnChanBufferEnding(self, Chan, Client):
        return _znc_core.CModules_OnChanBufferEnding(self, Chan, Client)

    def OnChanBufferPlayLine2(self, Chan, Client, sLine, tv):
        return _znc_core.CModules_OnChanBufferPlayLine2(self, Chan, Client, sLine, tv)

    def OnChanBufferPlayLine(self, Chan, Client, sLine):
        return _znc_core.CModules_OnChanBufferPlayLine(self, Chan, Client, sLine)

    def OnPrivBufferStarting(self, Query, Client):
        return _znc_core.CModules_OnPrivBufferStarting(self, Query, Client)

    def OnPrivBufferEnding(self, Query, Client):
        return _znc_core.CModules_OnPrivBufferEnding(self, Query, Client)

    def OnPrivBufferPlayLine2(self, Client, sLine, tv):
        return _znc_core.CModules_OnPrivBufferPlayLine2(self, Client, sLine, tv)

    def OnPrivBufferPlayLine(self, Client, sLine):
        return _znc_core.CModules_OnPrivBufferPlayLine(self, Client, sLine)

    def OnChanBufferPlayMessage(self, Message):
        return _znc_core.CModules_OnChanBufferPlayMessage(self, Message)

    def OnPrivBufferPlayMessage(self, Message):
        return _znc_core.CModules_OnPrivBufferPlayMessage(self, Message)

    def OnClientLogin(self):
        return _znc_core.CModules_OnClientLogin(self)

    def OnClientDisconnect(self):
        return _znc_core.CModules_OnClientDisconnect(self)

    def OnUserRaw(self, sLine):
        return _znc_core.CModules_OnUserRaw(self, sLine)

    def OnUserRawMessage(self, Message):
        return _znc_core.CModules_OnUserRawMessage(self, Message)

    def OnUserCTCPReply(self, sTarget, sMessage):
        return _znc_core.CModules_OnUserCTCPReply(self, sTarget, sMessage)

    def OnUserCTCPReplyMessage(self, Message):
        return _znc_core.CModules_OnUserCTCPReplyMessage(self, Message)

    def OnUserCTCP(self, sTarget, sMessage):
        return _znc_core.CModules_OnUserCTCP(self, sTarget, sMessage)

    def OnUserCTCPMessage(self, Message):
        return _znc_core.CModules_OnUserCTCPMessage(self, Message)

    def OnUserAction(self, sTarget, sMessage):
        return _znc_core.CModules_OnUserAction(self, sTarget, sMessage)

    def OnUserActionMessage(self, Message):
        return _znc_core.CModules_OnUserActionMessage(self, Message)

    def OnUserMsg(self, sTarget, sMessage):
        return _znc_core.CModules_OnUserMsg(self, sTarget, sMessage)

    def OnUserTextMessage(self, Message):
        return _znc_core.CModules_OnUserTextMessage(self, Message)

    def OnUserNotice(self, sTarget, sMessage):
        return _znc_core.CModules_OnUserNotice(self, sTarget, sMessage)

    def OnUserNoticeMessage(self, Message):
        return _znc_core.CModules_OnUserNoticeMessage(self, Message)

    def OnUserJoin(self, sChannel, sKey):
        return _znc_core.CModules_OnUserJoin(self, sChannel, sKey)

    def OnUserJoinMessage(self, Message):
        return _znc_core.CModules_OnUserJoinMessage(self, Message)

    def OnUserPart(self, sChannel, sMessage):
        return _znc_core.CModules_OnUserPart(self, sChannel, sMessage)

    def OnUserPartMessage(self, Message):
        return _znc_core.CModules_OnUserPartMessage(self, Message)

    def OnUserTopic(self, sChannel, sTopic):
        return _znc_core.CModules_OnUserTopic(self, sChannel, sTopic)

    def OnUserTopicMessage(self, Message):
        return _znc_core.CModules_OnUserTopicMessage(self, Message)

    def OnUserTopicRequest(self, sChannel):
        return _znc_core.CModules_OnUserTopicRequest(self, sChannel)

    def OnUserQuit(self, sMessage):
        return _znc_core.CModules_OnUserQuit(self, sMessage)

    def OnUserQuitMessage(self, Message):
        return _znc_core.CModules_OnUserQuitMessage(self, Message)

    def OnCTCPReply(self, Nick, sMessage):
        return _znc_core.CModules_OnCTCPReply(self, Nick, sMessage)

    def OnCTCPReplyMessage(self, Message):
        return _znc_core.CModules_OnCTCPReplyMessage(self, Message)

    def OnPrivCTCP(self, Nick, sMessage):
        return _znc_core.CModules_OnPrivCTCP(self, Nick, sMessage)

    def OnPrivCTCPMessage(self, Message):
        return _znc_core.CModules_OnPrivCTCPMessage(self, Message)

    def OnChanCTCP(self, Nick, Channel, sMessage):
        return _znc_core.CModules_OnChanCTCP(self, Nick, Channel, sMessage)

    def OnChanCTCPMessage(self, Message):
        return _znc_core.CModules_OnChanCTCPMessage(self, Message)

    def OnPrivAction(self, Nick, sMessage):
        return _znc_core.CModules_OnPrivAction(self, Nick, sMessage)

    def OnPrivActionMessage(self, Message):
        return _znc_core.CModules_OnPrivActionMessage(self, Message)

    def OnChanAction(self, Nick, Channel, sMessage):
        return _znc_core.CModules_OnChanAction(self, Nick, Channel, sMessage)

    def OnChanActionMessage(self, Message):
        return _znc_core.CModules_OnChanActionMessage(self, Message)

    def OnPrivMsg(self, Nick, sMessage):
        return _znc_core.CModules_OnPrivMsg(self, Nick, sMessage)

    def OnPrivTextMessage(self, Message):
        return _znc_core.CModules_OnPrivTextMessage(self, Message)

    def OnChanMsg(self, Nick, Channel, sMessage):
        return _znc_core.CModules_OnChanMsg(self, Nick, Channel, sMessage)

    def OnChanTextMessage(self, Message):
        return _znc_core.CModules_OnChanTextMessage(self, Message)

    def OnPrivNotice(self, Nick, sMessage):
        return _znc_core.CModules_OnPrivNotice(self, Nick, sMessage)

    def OnPrivNoticeMessage(self, Message):
        return _znc_core.CModules_OnPrivNoticeMessage(self, Message)

    def OnChanNotice(self, Nick, Channel, sMessage):
        return _znc_core.CModules_OnChanNotice(self, Nick, Channel, sMessage)

    def OnChanNoticeMessage(self, Message):
        return _znc_core.CModules_OnChanNoticeMessage(self, Message)

    def OnTopic(self, Nick, Channel, sTopic):
        return _znc_core.CModules_OnTopic(self, Nick, Channel, sTopic)

    def OnTopicMessage(self, Message):
        return _znc_core.CModules_OnTopicMessage(self, Message)

    def OnTimerAutoJoin(self, Channel):
        return _znc_core.CModules_OnTimerAutoJoin(self, Channel)

    def OnAddNetwork(self, Network, sErrorRet):
        return _znc_core.CModules_OnAddNetwork(self, Network, sErrorRet)

    def OnDeleteNetwork(self, Network):
        return _znc_core.CModules_OnDeleteNetwork(self, Network)

    def OnSendToClient(self, sLine, Client):
        return _znc_core.CModules_OnSendToClient(self, sLine, Client)

    def OnSendToClientMessage(self, Message):
        return _znc_core.CModules_OnSendToClientMessage(self, Message)

    def OnSendToIRC(self, sLine):
        return _znc_core.CModules_OnSendToIRC(self, sLine)

    def OnSendToIRCMessage(self, Message):
        return _znc_core.CModules_OnSendToIRCMessage(self, Message)

    def OnClientAttached(self):
        return _znc_core.CModules_OnClientAttached(self)

    def OnClientDetached(self):
        return _znc_core.CModules_OnClientDetached(self)

    def OnServerCapAvailable(self, sCap, sValue):
        return _znc_core.CModules_OnServerCapAvailable(self, sCap, sValue)

    def OnServerCapResult(self, sCap, bSuccess):
        return _znc_core.CModules_OnServerCapResult(self, sCap, bSuccess)

    def FindModule(self, sModule):
        return _znc_core.CModules_FindModule(self, sModule)

    def LoadModule(self, sModule, sArgs, eType, pUser, pNetwork, sRetMsg):
        return _znc_core.CModules_LoadModule(self, sModule, sArgs, eType, pUser, pNetwork, sRetMsg)

    def UnloadModule(self, *args):
        return _znc_core.CModules_UnloadModule(self, *args)

    def ReloadModule(self, sModule, sArgs, pUser, pNetwork, sRetMsg):
        return _znc_core.CModules_ReloadModule(self, sModule, sArgs, pUser, pNetwork, sRetMsg)

    @staticmethod
    def GetModInfo(ModInfo, sModule, sRetMsg):
        return _znc_core.CModules_GetModInfo(ModInfo, sModule, sRetMsg)

    @staticmethod
    def GetModPathInfo(ModInfo, sModule, sModPath, sRetMsg):
        return _znc_core.CModules_GetModPathInfo(ModInfo, sModule, sModPath, sRetMsg)

    @staticmethod
    def GetAvailableMods(*args):
        return _znc_core.CModules_GetAvailableMods(*args)

    @staticmethod
    def GetDefaultMods(*args):
        return _znc_core.CModules_GetDefaultMods(*args)

    @staticmethod
    def FindModPath(sModule, sModPath, sDataPath):
        return _znc_core.CModules_FindModPath(sModule, sModPath, sDataPath)

    @staticmethod
    def GetModDirs():
        return _znc_core.CModules_GetModDirs()

    def OnAddUser(self, User, sErrorRet):
        return _znc_core.CModules_OnAddUser(self, User, sErrorRet)

    def OnDeleteUser(self, User):
        return _znc_core.CModules_OnDeleteUser(self, User)

    def OnClientConnect(self, pSock, sHost, uPort):
        return _znc_core.CModules_OnClientConnect(self, pSock, sHost, uPort)

    def OnLoginAttempt(self, Auth):
        return _znc_core.CModules_OnLoginAttempt(self, Auth)

    def OnFailedLogin(self, sUsername, sRemoteIP):
        return _znc_core.CModules_OnFailedLogin(self, sUsername, sRemoteIP)

    def OnUnknownUserRaw(self, pClient, sLine):
        return _znc_core.CModules_OnUnknownUserRaw(self, pClient, sLine)

    def OnUnknownUserRawMessage(self, Message):
        return _znc_core.CModules_OnUnknownUserRawMessage(self, Message)

    def OnClientCapLs(self, pClient, ssCaps):
        return _znc_core.CModules_OnClientCapLs(self, pClient, ssCaps)

    def IsClientCapSupported(self, pClient, sCap, bState):
        return _znc_core.CModules_IsClientCapSupported(self, pClient, sCap, bState)

    def OnClientCapRequest(self, pClient, sCap, bState):
        return _znc_core.CModules_OnClientCapRequest(self, pClient, sCap, bState)

    def OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg):
        return _znc_core.CModules_OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg)

    def OnModuleUnloading(self, pModule, bSuccess, sRetMsg):
        return _znc_core.CModules_OnModuleUnloading(self, pModule, bSuccess, sRetMsg)

    def OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg):
        return _znc_core.CModules_OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg)

    def OnGetAvailableMods(self, ssMods, eType):
        return _znc_core.CModules_OnGetAvailableMods(self, ssMods, eType)

    def removeModule(self, p):
        return _znc_core.CModules_removeModule(self, p)

# Register CModules in _znc_core:
_znc_core.CModules_swigregister(CModules)
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):
        return _znc_core.CNick_Reset(self)

    def Parse(self, sNickMask):
        return _znc_core.CNick_Parse(self, sNickMask)

    def GetHostMask(self):
        return _znc_core.CNick_GetHostMask(self)

    def GetCommonChans(self, vChans, pNetwork):
        return _znc_core.CNick_GetCommonChans(self, vChans, pNetwork)

    def NickEquals(self, nickname):
        return _znc_core.CNick_NickEquals(self, nickname)

    def SetNetwork(self, pNetwork):
        return _znc_core.CNick_SetNetwork(self, pNetwork)

    def SetNick(self, s):
        return _znc_core.CNick_SetNick(self, s)

    def SetIdent(self, s):
        return _znc_core.CNick_SetIdent(self, s)

    def SetHost(self, s):
        return _znc_core.CNick_SetHost(self, s)

    def AddPerm(self, cPerm):
        return _znc_core.CNick_AddPerm(self, cPerm)

    def RemPerm(self, cPerm):
        return _znc_core.CNick_RemPerm(self, cPerm)

    def GetPermStr(self):
        return _znc_core.CNick_GetPermStr(self)

    def GetPermChar(self):
        return _znc_core.CNick_GetPermChar(self)

    def HasPerm(self, cPerm):
        return _znc_core.CNick_HasPerm(self, cPerm)

    def GetNick(self):
        return _znc_core.CNick_GetNick(self)

    def GetIdent(self):
        return _znc_core.CNick_GetIdent(self)

    def GetHost(self):
        return _znc_core.CNick_GetHost(self)

    def GetNickMask(self):
        return _znc_core.CNick_GetNickMask(self)

    def Clone(self, SourceNick):
        return _znc_core.CNick_Clone(self, SourceNick)

    def __str__(self):
        return _znc_core.CNick___str__(self)

    def __repr__(self):
        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, pNetwork, bInConfig, pConfig=None):
        _znc_core.CChan_swiginit(self, _znc_core.new_CChan(sName, pNetwork, bInConfig, pConfig))
    __swig_destroy__ = _znc_core.delete_CChan

    def Reset(self):
        return _znc_core.CChan_Reset(self)

    def ToConfig(self):
        return _znc_core.CChan_ToConfig(self)

    def Clone(self, chan):
        return _znc_core.CChan_Clone(self, chan)

    def Cycle(self):
        return _znc_core.CChan_Cycle(self)

    def JoinUser(self, *args):
        return _znc_core.CChan_JoinUser(self, *args)

    def AttachUser(self, pClient=None):
        return _znc_core.CChan_AttachUser(self, pClient)

    def DetachUser(self):
        return _znc_core.CChan_DetachUser(self)

    def OnWho(self, sNick, sIdent, sHost):
        return _znc_core.CChan_OnWho(self, sNick, sIdent, sHost)

    def SetModes(self, *args):
        return _znc_core.CChan_SetModes(self, *args)

    def ModeChange(self, *args):
        return _znc_core.CChan_ModeChange(self, *args)

    def AddMode(self, cMode, sArg):
        return _znc_core.CChan_AddMode(self, cMode, sArg)

    def RemMode(self, cMode):
        return _znc_core.CChan_RemMode(self, cMode)

    def GetModeString(self):
        return _znc_core.CChan_GetModeString(self)

    def GetModeForNames(self):
        return _znc_core.CChan_GetModeForNames(self)

    def ClearNicks(self):
        return _znc_core.CChan_ClearNicks(self)

    def FindNick(self, *args):
        return _znc_core.CChan_FindNick(self, *args)

    def AddNicks(self, sNicks):
        return _znc_core.CChan_AddNicks(self, sNicks)

    def AddNick(self, sNick):
        return _znc_core.CChan_AddNick(self, sNick)

    def RemNick(self, sNick):
        return _znc_core.CChan_RemNick(self, sNick)

    def ChangeNick(self, sOldNick, sNewNick):
        return _znc_core.CChan_ChangeNick(self, sOldNick, sNewNick)

    def GetBuffer(self):
        return _znc_core.CChan_GetBuffer(self)

    def GetBufferCount(self):
        return _znc_core.CChan_GetBufferCount(self)

    def SetBufferCount(self, u, bForce=False):
        return _znc_core.CChan_SetBufferCount(self, u, bForce)

    def InheritBufferCount(self, u, bForce=False):
        return _znc_core.CChan_InheritBufferCount(self, u, bForce)

    def ResetBufferCount(self):
        return _znc_core.CChan_ResetBufferCount(self)

    def AddBuffer(self, *args):
        return _znc_core.CChan_AddBuffer(self, *args)

    def ClearBuffer(self):
        return _znc_core.CChan_ClearBuffer(self)

    def SendBuffer(self, *args):
        return _znc_core.CChan_SendBuffer(self, *args)

    def GetPermStr(self):
        return _znc_core.CChan_GetPermStr(self)

    def HasPerm(self, cPerm):
        return _znc_core.CChan_HasPerm(self, cPerm)

    def AddPerm(self, cPerm):
        return _znc_core.CChan_AddPerm(self, cPerm)

    def RemPerm(self, cPerm):
        return _znc_core.CChan_RemPerm(self, cPerm)

    def SetModeKnown(self, b):
        return _znc_core.CChan_SetModeKnown(self, b)

    def SetIsOn(self, b):
        return _znc_core.CChan_SetIsOn(self, b)

    def SetKey(self, s):
        return _znc_core.CChan_SetKey(self, s)

    def SetTopic(self, s):
        return _znc_core.CChan_SetTopic(self, s)

    def SetTopicOwner(self, s):
        return _znc_core.CChan_SetTopicOwner(self, s)

    def SetTopicDate(self, u):
        return _znc_core.CChan_SetTopicDate(self, u)

    def SetDefaultModes(self, s):
        return _znc_core.CChan_SetDefaultModes(self, s)

    def SetAutoClearChanBuffer(self, b):
        return _znc_core.CChan_SetAutoClearChanBuffer(self, b)

    def InheritAutoClearChanBuffer(self, b):
        return _znc_core.CChan_InheritAutoClearChanBuffer(self, b)

    def ResetAutoClearChanBuffer(self):
        return _znc_core.CChan_ResetAutoClearChanBuffer(self)

    def SetDetached(self, b=True):
        return _znc_core.CChan_SetDetached(self, b)

    def SetInConfig(self, b):
        return _znc_core.CChan_SetInConfig(self, b)

    def SetCreationDate(self, u):
        return _znc_core.CChan_SetCreationDate(self, u)

    def Disable(self):
        return _znc_core.CChan_Disable(self)

    def Enable(self):
        return _znc_core.CChan_Enable(self)

    def IncJoinTries(self):
        return _znc_core.CChan_IncJoinTries(self)

    def ResetJoinTries(self):
        return _znc_core.CChan_ResetJoinTries(self)

    def GetNetwork(self):
        return _znc_core.CChan_GetNetwork(self)

    def IsModeKnown(self):
        return _znc_core.CChan_IsModeKnown(self)

    def HasMode(self, cMode):
        return _znc_core.CChan_HasMode(self, cMode)

    def GetOptions(self):
        return _znc_core.CChan_GetOptions(self)

    def GetModeArg(self, *args):
        return _znc_core.CChan_GetModeArg(self, *args)

    def GetPermCounts(self):
        return _znc_core.CChan_GetPermCounts(self)

    def IsOn(self):
        return _znc_core.CChan_IsOn(self)

    def GetName(self):
        return _znc_core.CChan_GetName(self)

    def GetModes(self):
        return _znc_core.CChan_GetModes(self)

    def GetKey(self):
        return _znc_core.CChan_GetKey(self)

    def GetTopic(self):
        return _znc_core.CChan_GetTopic(self)

    def GetTopicOwner(self):
        return _znc_core.CChan_GetTopicOwner(self)

    def GetTopicDate(self):
        return _znc_core.CChan_GetTopicDate(self)

    def GetDefaultModes(self):
        return _znc_core.CChan_GetDefaultModes(self)

    def GetNicks(self):
        return _znc_core.CChan_GetNicks(self)

    def GetNickCount(self):
        return _znc_core.CChan_GetNickCount(self)

    def AutoClearChanBuffer(self):
        return _znc_core.CChan_AutoClearChanBuffer(self)

    def IsDetached(self):
        return _znc_core.CChan_IsDetached(self)

    def InConfig(self):
        return _znc_core.CChan_InConfig(self)

    def GetCreationDate(self):
        return _znc_core.CChan_GetCreationDate(self)

    def IsDisabled(self):
        return _znc_core.CChan_IsDisabled(self)

    def GetJoinTries(self):
        return _znc_core.CChan_GetJoinTries(self)

    def HasBufferCountSet(self):
        return _znc_core.CChan_HasBufferCountSet(self)

    def HasAutoClearChanBufferSet(self):
        return _znc_core.CChan_HasAutoClearChanBufferSet(self)

    def __str__(self):
        return _znc_core.CChan___str__(self)

    def __repr__(self):
        return _znc_core.CChan___repr__(self)

    def GetNicks_(self):
        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):
        _znc_core.CUser_swiginit(self, _znc_core.new_CUser(sUsername))
    __swig_destroy__ = _znc_core.delete_CUser

    def ParseConfig(self, Config, sError):
        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_ARGON2ID = _znc_core.CUser_HASH_ARGON2ID
    HASH_DEFAULT = _znc_core.CUser_HASH_DEFAULT

    @staticmethod
    def SaltedHash(sPass, sSalt):
        return _znc_core.CUser_SaltedHash(sPass, sSalt)

    def ToConfig(self):
        return _znc_core.CUser_ToConfig(self)

    def CheckPass(self, sPass):
        return _znc_core.CUser_CheckPass(self, sPass)

    def AddAllowedHost(self, sHostMask):
        return _znc_core.CUser_AddAllowedHost(self, sHostMask)

    def RemAllowedHost(self, sHostMask):
        return _znc_core.CUser_RemAllowedHost(self, sHostMask)

    def ClearAllowedHosts(self):
        return _znc_core.CUser_ClearAllowedHosts(self)

    def IsHostAllowed(self, sHost):
        return _znc_core.CUser_IsHostAllowed(self, sHost)

    def IsValid(self, sErrMsg, bSkipPass=False):
        return _znc_core.CUser_IsValid(self, sErrMsg, bSkipPass)

    @staticmethod
    def IsValidUsername(sUsername):
        return _znc_core.CUser_IsValidUsername(sUsername)

    @staticmethod
    def IsValidUserName(sUsername):
        return _znc_core.CUser_IsValidUserName(sUsername)

    @staticmethod
    def MakeCleanUsername(sUsername):
        return _znc_core.CUser_MakeCleanUsername(sUsername)

    @staticmethod
    def MakeCleanUserName(sUsername):
        return _znc_core.CUser_MakeCleanUserName(sUsername)

    def GetModules(self, *args):
        return _znc_core.CUser_GetModules(self, *args)

    def DeleteNetwork(self, sNetwork):
        return _znc_core.CUser_DeleteNetwork(self, sNetwork)

    def AddNetwork(self, *args):
        return _znc_core.CUser_AddNetwork(self, *args)

    def RemoveNetwork(self, pNetwork):
        return _znc_core.CUser_RemoveNetwork(self, pNetwork)

    def FindNetwork(self, sNetwork):
        return _znc_core.CUser_FindNetwork(self, sNetwork)

    def GetNetworks(self):
        return _znc_core.CUser_GetNetworks(self)

    def HasSpaceForNewNetwork(self):
        return _znc_core.CUser_HasSpaceForNewNetwork(self)

    def PutUser(self, sLine, pClient=None, pSkipClient=None):
        return _znc_core.CUser_PutUser(self, sLine, pClient, pSkipClient)

    def PutAllUser(self, sLine, pClient=None, pSkipClient=None):
        return _znc_core.CUser_PutAllUser(self, sLine, pClient, pSkipClient)

    def PutStatus(self, sLine, pClient=None, pSkipClient=None):
        return _znc_core.CUser_PutStatus(self, sLine, pClient, pSkipClient)

    def PutStatusNotice(self, sLine, pClient=None, pSkipClient=None):
        return _znc_core.CUser_PutStatusNotice(self, sLine, pClient, pSkipClient)

    def PutModule(self, sModule, sLine, pClient=None, pSkipClient=None):
        return _znc_core.CUser_PutModule(self, sModule, sLine, pClient, pSkipClient)

    def PutModNotice(self, sModule, sLine, pClient=None, pSkipClient=None):
        return _znc_core.CUser_PutModNotice(self, sModule, sLine, pClient, pSkipClient)

    def IsUserAttached(self):
        return _znc_core.CUser_IsUserAttached(self)

    def UserConnected(self, pClient):
        return _znc_core.CUser_UserConnected(self, pClient)

    def UserDisconnected(self, pClient):
        return _znc_core.CUser_UserDisconnected(self, pClient)

    def GetLocalDCCIP(self):
        return _znc_core.CUser_GetLocalDCCIP(self)

    def ExpandString(self, *args):
        return _znc_core.CUser_ExpandString(self, *args)

    def AddTimestamp(self, *args):
        return _znc_core.CUser_AddTimestamp(self, *args)

    def CloneNetworks(self, User):
        return _znc_core.CUser_CloneNetworks(self, User)

    def Clone(self, User, sErrorRet, bCloneNetworks=True):
        return _znc_core.CUser_Clone(self, User, sErrorRet, bCloneNetworks)

    def BounceAllClients(self):
        return _znc_core.CUser_BounceAllClients(self)

    def AddBytesRead(self, u):
        return _znc_core.CUser_AddBytesRead(self, u)

    def AddBytesWritten(self, u):
        return _znc_core.CUser_AddBytesWritten(self, u)

    def SetNick(self, s):
        return _znc_core.CUser_SetNick(self, s)

    def SetAltNick(self, s):
        return _znc_core.CUser_SetAltNick(self, s)

    def SetIdent(self, s):
        return _znc_core.CUser_SetIdent(self, s)

    def SetRealName(self, s):
        return _znc_core.CUser_SetRealName(self, s)

    def SetBindHost(self, s):
        return _znc_core.CUser_SetBindHost(self, s)

    def SetDCCBindHost(self, s):
        return _znc_core.CUser_SetDCCBindHost(self, s)

    def SetPass(self, *args):
        return _znc_core.CUser_SetPass(self, *args)

    def SetMultiClients(self, b):
        return _znc_core.CUser_SetMultiClients(self, b)

    def SetDenyLoadMod(self, b):
        return _znc_core.CUser_SetDenyLoadMod(self, b)

    def SetAdmin(self, b):
        return _znc_core.CUser_SetAdmin(self, b)

    def SetDenySetBindHost(self, b):
        return _znc_core.CUser_SetDenySetBindHost(self, b)

    def SetDenySetIdent(self, b):
        return _znc_core.CUser_SetDenySetIdent(self, b)

    def SetDenySetNetwork(self, b):
        return _znc_core.CUser_SetDenySetNetwork(self, b)

    def SetDenySetRealName(self, b):
        return _znc_core.CUser_SetDenySetRealName(self, b)

    def SetDenySetQuitMsg(self, b):
        return _znc_core.CUser_SetDenySetQuitMsg(self, b)

    def SetDenySetCTCPReplies(self, b):
        return _znc_core.CUser_SetDenySetCTCPReplies(self, b)

    def SetStatusPrefix(self, s):
        return _znc_core.CUser_SetStatusPrefix(self, s)

    def SetDefaultChanModes(self, s):
        return _znc_core.CUser_SetDefaultChanModes(self, s)

    def SetClientEncoding(self, s):
        return _znc_core.CUser_SetClientEncoding(self, s)

    def SetQuitMsg(self, s):
        return _znc_core.CUser_SetQuitMsg(self, s)

    def AddCTCPReply(self, sCTCP, sReply):
        return _znc_core.CUser_AddCTCPReply(self, sCTCP, sReply)

    def DelCTCPReply(self, sCTCP):
        return _znc_core.CUser_DelCTCPReply(self, sCTCP)

    def SetBufferCount(self, u, bForce=False):
        return _znc_core.CUser_SetBufferCount(self, u, bForce)

    def SetChanBufferSize(self, u, bForce=False):
        return _znc_core.CUser_SetChanBufferSize(self, u, bForce)

    def SetQueryBufferSize(self, u, bForce=False):
        return _znc_core.CUser_SetQueryBufferSize(self, u, bForce)

    def SetAutoClearChanBuffer(self, b):
        return _znc_core.CUser_SetAutoClearChanBuffer(self, b)

    def SetAutoClearQueryBuffer(self, b):
        return _znc_core.CUser_SetAutoClearQueryBuffer(self, b)

    def SetLanguage(self, s):
        return _znc_core.CUser_SetLanguage(self, s)

    def SetBeingDeleted(self, b):
        return _znc_core.CUser_SetBeingDeleted(self, b)

    def SetTimestampFormat(self, s):
        return _znc_core.CUser_SetTimestampFormat(self, s)

    def SetTimestampAppend(self, b):
        return _znc_core.CUser_SetTimestampAppend(self, b)

    def SetTimestampPrepend(self, b):
        return _znc_core.CUser_SetTimestampPrepend(self, b)

    def SetAuthOnlyViaModule(self, b):
        return _znc_core.CUser_SetAuthOnlyViaModule(self, b)

    def SetTimezone(self, s):
        return _znc_core.CUser_SetTimezone(self, s)

    def SetJoinTries(self, i):
        return _znc_core.CUser_SetJoinTries(self, i)

    def SetMaxJoins(self, i):
        return _znc_core.CUser_SetMaxJoins(self, i)

    def SetSkinName(self, s):
        return _znc_core.CUser_SetSkinName(self, s)

    def SetMaxNetworks(self, i):
        return _znc_core.CUser_SetMaxNetworks(self, i)

    def SetMaxQueryBuffers(self, i):
        return _znc_core.CUser_SetMaxQueryBuffers(self, i)

    def SetNoTrafficTimeout(self, i):
        return _znc_core.CUser_SetNoTrafficTimeout(self, i)

    def GetUserClients(self):
        return _znc_core.CUser_GetUserClients(self)

    def GetAllClients(self):
        return _znc_core.CUser_GetAllClients(self)

    def GetUserName(self):
        return _znc_core.CUser_GetUserName(self)

    def GetUsername(self):
        return _znc_core.CUser_GetUsername(self)

    def GetCleanUserName(self):
        return _znc_core.CUser_GetCleanUserName(self)

    def GetNick(self, bAllowDefault=True):
        return _znc_core.CUser_GetNick(self, bAllowDefault)

    def GetAltNick(self, bAllowDefault=True):
        return _znc_core.CUser_GetAltNick(self, bAllowDefault)

    def GetIdent(self, bAllowDefault=True):
        return _znc_core.CUser_GetIdent(self, bAllowDefault)

    def GetRealName(self):
        return _znc_core.CUser_GetRealName(self)

    def GetBindHost(self):
        return _znc_core.CUser_GetBindHost(self)

    def GetDCCBindHost(self):
        return _znc_core.CUser_GetDCCBindHost(self)

    def GetPass(self):
        return _znc_core.CUser_GetPass(self)

    def GetPassHashType(self):
        return _znc_core.CUser_GetPassHashType(self)

    def GetPassSalt(self):
        return _znc_core.CUser_GetPassSalt(self)

    def GetAllowedHosts(self):
        return _znc_core.CUser_GetAllowedHosts(self)

    def GetTimestampFormat(self):
        return _znc_core.CUser_GetTimestampFormat(self)

    def GetClientEncoding(self):
        return _znc_core.CUser_GetClientEncoding(self)

    def GetTimestampAppend(self):
        return _znc_core.CUser_GetTimestampAppend(self)

    def GetTimestampPrepend(self):
        return _znc_core.CUser_GetTimestampPrepend(self)

    def GetUserPath(self):
        return _znc_core.CUser_GetUserPath(self)

    def DenyLoadMod(self):
        return _znc_core.CUser_DenyLoadMod(self)

    def IsAdmin(self):
        return _znc_core.CUser_IsAdmin(self)

    def DenySetBindHost(self):
        return _znc_core.CUser_DenySetBindHost(self)

    def DenySetIdent(self):
        return _znc_core.CUser_DenySetIdent(self)

    def DenySetNetwork(self):
        return _znc_core.CUser_DenySetNetwork(self)

    def DenySetRealName(self):
        return _znc_core.CUser_DenySetRealName(self)

    def DenySetQuitMsg(self):
        return _znc_core.CUser_DenySetQuitMsg(self)

    def DenySetCTCPReplies(self):
        return _znc_core.CUser_DenySetCTCPReplies(self)

    def MultiClients(self):
        return _znc_core.CUser_MultiClients(self)

    def AuthOnlyViaModule(self):
        return _znc_core.CUser_AuthOnlyViaModule(self)

    def GetStatusPrefix(self):
        return _znc_core.CUser_GetStatusPrefix(self)

    def GetDefaultChanModes(self):
        return _znc_core.CUser_GetDefaultChanModes(self)

    def GetPingFrequency(self):
        return _znc_core.CUser_GetPingFrequency(self)

    def GetPingSlack(self):
        return _znc_core.CUser_GetPingSlack(self)

    def GetNoTrafficTimeout(self):
        return _znc_core.CUser_GetNoTrafficTimeout(self)

    def GetQuitMsg(self):
        return _znc_core.CUser_GetQuitMsg(self)

    def GetCTCPReplies(self):
        return _znc_core.CUser_GetCTCPReplies(self)

    def GetBufferCount(self):
        return _znc_core.CUser_GetBufferCount(self)

    def GetChanBufferSize(self):
        return _znc_core.CUser_GetChanBufferSize(self)

    def GetQueryBufferSize(self):
        return _znc_core.CUser_GetQueryBufferSize(self)

    def AutoClearChanBuffer(self):
        return _znc_core.CUser_AutoClearChanBuffer(self)

    def AutoClearQueryBuffer(self):
        return _znc_core.CUser_AutoClearQueryBuffer(self)

    def IsBeingDeleted(self):
        return _znc_core.CUser_IsBeingDeleted(self)

    def GetTimezone(self):
        return _znc_core.CUser_GetTimezone(self)

    def BytesRead(self):
        return _znc_core.CUser_BytesRead(self)

    def BytesWritten(self):
        return _znc_core.CUser_BytesWritten(self)

    def JoinTries(self):
        return _znc_core.CUser_JoinTries(self)

    def MaxJoins(self):
        return _znc_core.CUser_MaxJoins(self)

    def GetSkinName(self):
        return _znc_core.CUser_GetSkinName(self)

    def GetLanguage(self):
        return _znc_core.CUser_GetLanguage(self)

    def MaxNetworks(self):
        return _znc_core.CUser_MaxNetworks(self)

    def MaxQueryBuffers(self):
        return _znc_core.CUser_MaxQueryBuffers(self)

    def __str__(self):
        return _znc_core.CUser___str__(self)

    def __repr__(self):
        return _znc_core.CUser___repr__(self)

    def GetNetworks_(self):
        return _znc_core.CUser_GetNetworks_(self)

# Register CUser in _znc_core:
_znc_core.CUser_swigregister(CUser)
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):
        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, bCloneName=True):
        return _znc_core.CIRCNetwork_Clone(self, Network, bCloneName)

    def GetNetworkPath(self):
        return _znc_core.CIRCNetwork_GetNetworkPath(self)

    def DelServers(self):
        return _znc_core.CIRCNetwork_DelServers(self)

    def ParseConfig(self, pConfig, sError, bUpgrade=False):
        return _znc_core.CIRCNetwork_ParseConfig(self, pConfig, sError, bUpgrade)

    def ToConfig(self):
        return _znc_core.CIRCNetwork_ToConfig(self)

    def BounceAllClients(self):
        return _znc_core.CIRCNetwork_BounceAllClients(self)

    def IsUserAttached(self):
        return _znc_core.CIRCNetwork_IsUserAttached(self)

    def IsUserOnline(self):
        return _znc_core.CIRCNetwork_IsUserOnline(self)

    def ClientConnected(self, pClient):
        return _znc_core.CIRCNetwork_ClientConnected(self, pClient)

    def ClientDisconnected(self, pClient):
        return _znc_core.CIRCNetwork_ClientDisconnected(self, pClient)

    def GetUser(self):
        return _znc_core.CIRCNetwork_GetUser(self)

    def GetName(self):
        return _znc_core.CIRCNetwork_GetName(self)

    def IsNetworkAttached(self):
        return _znc_core.CIRCNetwork_IsNetworkAttached(self)

    def GetClients(self):
        return _znc_core.CIRCNetwork_GetClients(self)

    def FindClients(self, sIdentifier):
        return _znc_core.CIRCNetwork_FindClients(self, sIdentifier)

    def SetUser(self, pUser):
        return _znc_core.CIRCNetwork_SetUser(self, pUser)

    def SetName(self, sName):
        return _znc_core.CIRCNetwork_SetName(self, sName)

    def GetModules(self, *args):
        return _znc_core.CIRCNetwork_GetModules(self, *args)

    def PutUser(self, *args):
        return _znc_core.CIRCNetwork_PutUser(self, *args)

    def PutStatus(self, sLine, pClient=None, pSkipClient=None):
        return _znc_core.CIRCNetwork_PutStatus(self, sLine, pClient, pSkipClient)

    def PutModule(self, sModule, sLine, pClient=None, pSkipClient=None):
        return _znc_core.CIRCNetwork_PutModule(self, sModule, sLine, pClient, pSkipClient)

    def GetChans(self):
        return _znc_core.CIRCNetwork_GetChans(self)

    def FindChan(self, sName):
        return _znc_core.CIRCNetwork_FindChan(self, sName)

    def FindChans(self, sWild):
        return _znc_core.CIRCNetwork_FindChans(self, sWild)

    def AddChan(self, *args):
        return _znc_core.CIRCNetwork_AddChan(self, *args)

    def DelChan(self, sName):
        return _znc_core.CIRCNetwork_DelChan(self, sName)

    def MoveChan(self, sChan, index, sError):
        return _znc_core.CIRCNetwork_MoveChan(self, sChan, index, sError)

    def SwapChans(self, sChan1, sChan2, sError):
        return _znc_core.CIRCNetwork_SwapChans(self, sChan1, sChan2, sError)

    def JoinChans(self, *args):
        return _znc_core.CIRCNetwork_JoinChans(self, *args)

    def GetQueries(self):
        return _znc_core.CIRCNetwork_GetQueries(self)

    def FindQuery(self, sName):
        return _znc_core.CIRCNetwork_FindQuery(self, sName)

    def FindQueries(self, sWild):
        return _znc_core.CIRCNetwork_FindQueries(self, sWild)

    def AddQuery(self, sName):
        return _znc_core.CIRCNetwork_AddQuery(self, sName)

    def DelQuery(self, sName):
        return _znc_core.CIRCNetwork_DelQuery(self, sName)

    def GetChanPrefixes(self):
        return _znc_core.CIRCNetwork_GetChanPrefixes(self)

    def SetChanPrefixes(self, s):
        return _znc_core.CIRCNetwork_SetChanPrefixes(self, s)

    def IsChan(self, sChan):
        return _znc_core.CIRCNetwork_IsChan(self, sChan)

    def GetServers(self):
        return _znc_core.CIRCNetwork_GetServers(self)

    def HasServers(self):
        return _znc_core.CIRCNetwork_HasServers(self)

    def FindServer(self, sName):
        return _znc_core.CIRCNetwork_FindServer(self, sName)

    def DelServer(self, sName, uPort, sPass):
        return _znc_core.CIRCNetwork_DelServer(self, sName, uPort, sPass)

    def AddServer(self, *args):
        return _znc_core.CIRCNetwork_AddServer(self, *args)

    def GetNextServer(self, bAdvance=True):
        return _znc_core.CIRCNetwork_GetNextServer(self, bAdvance)

    def GetCurrentServer(self):
        return _znc_core.CIRCNetwork_GetCurrentServer(self)

    def SetIRCServer(self, s):
        return _znc_core.CIRCNetwork_SetIRCServer(self, s)

    def SetNextServer(self, pServer):
        return _znc_core.CIRCNetwork_SetNextServer(self, pServer)

    def IsLastServer(self):
        return _znc_core.CIRCNetwork_IsLastServer(self)

    def GetTrustedFingerprints(self):
        return _znc_core.CIRCNetwork_GetTrustedFingerprints(self)

    def AddTrustedFingerprint(self, sFP):
        return _znc_core.CIRCNetwork_AddTrustedFingerprint(self, sFP)

    def DelTrustedFingerprint(self, sFP):
        return _znc_core.CIRCNetwork_DelTrustedFingerprint(self, sFP)

    def ClearTrustedFingerprints(self):
        return _znc_core.CIRCNetwork_ClearTrustedFingerprints(self)

    def SetIRCConnectEnabled(self, b):
        return _znc_core.CIRCNetwork_SetIRCConnectEnabled(self, b)

    def GetIRCConnectEnabled(self):
        return _znc_core.CIRCNetwork_GetIRCConnectEnabled(self)

    def GetIRCSock(self, *args):
        return _znc_core.CIRCNetwork_GetIRCSock(self, *args)

    def GetIRCServer(self):
        return _znc_core.CIRCNetwork_GetIRCServer(self)

    def GetIRCNick(self):
        return _znc_core.CIRCNetwork_GetIRCNick(self)

    def SetIRCNick(self, n):
        return _znc_core.CIRCNetwork_SetIRCNick(self, n)

    def GetCurNick(self):
        return _znc_core.CIRCNetwork_GetCurNick(self)

    def IsIRCAway(self):
        return _znc_core.CIRCNetwork_IsIRCAway(self)

    def SetIRCAway(self, b):
        return _znc_core.CIRCNetwork_SetIRCAway(self, b)

    def Connect(self):
        return _znc_core.CIRCNetwork_Connect(self)

    def IsIRCConnected(self):
        return _znc_core.CIRCNetwork_IsIRCConnected(self)

    def SetIRCSocket(self, pIRCSock):
        return _znc_core.CIRCNetwork_SetIRCSocket(self, pIRCSock)

    def IRCConnected(self):
        return _znc_core.CIRCNetwork_IRCConnected(self)

    def IRCDisconnected(self):
        return _znc_core.CIRCNetwork_IRCDisconnected(self)

    def CheckIRCConnect(self):
        return _znc_core.CIRCNetwork_CheckIRCConnect(self)

    def NotifyClientsAboutServerDependentCap(self, sCap, bValue):
        return _znc_core.CIRCNetwork_NotifyClientsAboutServerDependentCap(self, sCap, bValue)

    def IsServerCapAccepted(self, sCap):
        return _znc_core.CIRCNetwork_IsServerCapAccepted(self, sCap)

    def PutIRC(self, *args):
        return _znc_core.CIRCNetwork_PutIRC(self, *args)

    def ClearRawBuffer(self):
        return _znc_core.CIRCNetwork_ClearRawBuffer(self)

    def AddRawBuffer(self, *args):
        return _znc_core.CIRCNetwork_AddRawBuffer(self, *args)

    def UpdateRawBuffer(self, *args):
        return _znc_core.CIRCNetwork_UpdateRawBuffer(self, *args)

    def UpdateExactRawBuffer(self, *args):
        return _znc_core.CIRCNetwork_UpdateExactRawBuffer(self, *args)

    def ClearMotdBuffer(self):
        return _znc_core.CIRCNetwork_ClearMotdBuffer(self)

    def AddMotdBuffer(self, *args):
        return _znc_core.CIRCNetwork_AddMotdBuffer(self, *args)

    def UpdateMotdBuffer(self, *args):
        return _znc_core.CIRCNetwork_UpdateMotdBuffer(self, *args)

    def ClearNoticeBuffer(self):
        return _znc_core.CIRCNetwork_ClearNoticeBuffer(self)

    def AddNoticeBuffer(self, *args):
        return _znc_core.CIRCNetwork_AddNoticeBuffer(self, *args)

    def UpdateNoticeBuffer(self, *args):
        return _znc_core.CIRCNetwork_UpdateNoticeBuffer(self, *args)

    def ClearQueryBuffer(self):
        return _znc_core.CIRCNetwork_ClearQueryBuffer(self)

    def GetNick(self, bAllowDefault=True):
        return _znc_core.CIRCNetwork_GetNick(self, bAllowDefault)

    def GetAltNick(self, bAllowDefault=True):
        return _znc_core.CIRCNetwork_GetAltNick(self, bAllowDefault)

    def GetIdent(self, bAllowDefault=True):
        return _znc_core.CIRCNetwork_GetIdent(self, bAllowDefault)

    def GetRealName(self):
        return _znc_core.CIRCNetwork_GetRealName(self)

    def GetBindHost(self):
        return _znc_core.CIRCNetwork_GetBindHost(self)

    def GetEncoding(self):
        return _znc_core.CIRCNetwork_GetEncoding(self)

    def GetQuitMsg(self):
        return _znc_core.CIRCNetwork_GetQuitMsg(self)

    def SetNick(self, s):
        return _znc_core.CIRCNetwork_SetNick(self, s)

    def SetAltNick(self, s):
        return _znc_core.CIRCNetwork_SetAltNick(self, s)

    def SetIdent(self, s):
        return _znc_core.CIRCNetwork_SetIdent(self, s)

    def SetRealName(self, s):
        return _znc_core.CIRCNetwork_SetRealName(self, s)

    def SetBindHost(self, s):
        return _znc_core.CIRCNetwork_SetBindHost(self, s)

    def SetEncoding(self, s):
        return _znc_core.CIRCNetwork_SetEncoding(self, s)

    def SetQuitMsg(self, s):
        return _znc_core.CIRCNetwork_SetQuitMsg(self, s)

    def GetFloodRate(self):
        return _znc_core.CIRCNetwork_GetFloodRate(self)

    def GetFloodBurst(self):
        return _znc_core.CIRCNetwork_GetFloodBurst(self)

    def SetFloodRate(self, fFloodRate):
        return _znc_core.CIRCNetwork_SetFloodRate(self, fFloodRate)

    def SetFloodBurst(self, uFloodBurst):
        return _znc_core.CIRCNetwork_SetFloodBurst(self, uFloodBurst)

    def GetJoinDelay(self):
        return _znc_core.CIRCNetwork_GetJoinDelay(self)

    def SetJoinDelay(self, uJoinDelay):
        return _znc_core.CIRCNetwork_SetJoinDelay(self, uJoinDelay)

    def SetTrustAllCerts(self, bTrustAll=False):
        return _znc_core.CIRCNetwork_SetTrustAllCerts(self, bTrustAll)

    def GetTrustAllCerts(self):
        return _znc_core.CIRCNetwork_GetTrustAllCerts(self)

    def SetTrustPKI(self, bTrustPKI=True):
        return _znc_core.CIRCNetwork_SetTrustPKI(self, bTrustPKI)

    def GetTrustPKI(self):
        return _znc_core.CIRCNetwork_GetTrustPKI(self)

    def BytesRead(self):
        return _znc_core.CIRCNetwork_BytesRead(self)

    def BytesWritten(self):
        return _znc_core.CIRCNetwork_BytesWritten(self)

    def AddBytesRead(self, u):
        return _znc_core.CIRCNetwork_AddBytesRead(self, u)

    def AddBytesWritten(self, u):
        return _znc_core.CIRCNetwork_AddBytesWritten(self, u)

    def ExpandString(self, *args):
        return _znc_core.CIRCNetwork_ExpandString(self, *args)

    def __str__(self):
        return _znc_core.CIRCNetwork___str__(self)

    def __repr__(self):
        return _znc_core.CIRCNetwork___repr__(self)

    def GetChans_(self):
        return _znc_core.CIRCNetwork_GetChans_(self)

    def GetServers_(self):
        return _znc_core.CIRCNetwork_GetServers_(self)

    def GetQueries_(self):
        return _znc_core.CIRCNetwork_GetQueries_(self)

# Register CIRCNetwork in _znc_core:
_znc_core.CIRCNetwork_swigregister(CIRCNetwork)
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, pNetwork):
        _znc_core.CQuery_swiginit(self, _znc_core.new_CQuery(sName, pNetwork))
    __swig_destroy__ = _znc_core.delete_CQuery

    def GetBuffer(self):
        return _znc_core.CQuery_GetBuffer(self)

    def GetBufferCount(self):
        return _znc_core.CQuery_GetBufferCount(self)

    def SetBufferCount(self, u, bForce=False):
        return _znc_core.CQuery_SetBufferCount(self, u, bForce)

    def AddBuffer(self, *args):
        return _znc_core.CQuery_AddBuffer(self, *args)

    def ClearBuffer(self):
        return _znc_core.CQuery_ClearBuffer(self)

    def SendBuffer(self, *args):
        return _znc_core.CQuery_SendBuffer(self, *args)

    def GetName(self):
        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, sPassword, pSock):
        return _znc_core.CAuthBase_SetLoginInfo(self, sUsername, sPassword, pSock)

    def AcceptLogin(self, User):
        return _znc_core.CAuthBase_AcceptLogin(self, User)

    def RefuseLogin(self, sReason):
        return _znc_core.CAuthBase_RefuseLogin(self, sReason)

    def GetUsername(self):
        return _znc_core.CAuthBase_GetUsername(self)

    def GetPassword(self):
        return _znc_core.CAuthBase_GetPassword(self)

    def GetSocket(self):
        return _znc_core.CAuthBase_GetSocket(self)

    def GetRemoteIP(self):
        return _znc_core.CAuthBase_GetRemoteIP(self)

    def Invalidate(self):
        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, sUsername, sPassword):
        _znc_core.CClientAuth_swiginit(self, _znc_core.new_CClientAuth(pClient, sUsername, sPassword))
    __swig_destroy__ = _znc_core.delete_CClientAuth

    def Invalidate(self):
        return _znc_core.CClientAuth_Invalidate(self)

    def AcceptedLogin(self, User):
        return _znc_core.CClientAuth_AcceptedLogin(self, User)

    def RefusedLogin(self, sReason):
        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):
        return _znc_core.CClient_SendRequiredPasswordNotice(self)

    def AcceptLogin(self, User):
        return _znc_core.CClient_AcceptLogin(self, User)

    def RefuseLogin(self, sReason):
        return _znc_core.CClient_RefuseLogin(self, sReason)

    def GetNick(self, bAllowIRCNick=True):
        return _znc_core.CClient_GetNick(self, bAllowIRCNick)

    def GetNickMask(self):
        return _znc_core.CClient_GetNickMask(self)

    def GetIdentifier(self):
        return _znc_core.CClient_GetIdentifier(self)

    def CapVersion(self):
        return _znc_core.CClient_CapVersion(self)

    def HasCap302(self):
        return _znc_core.CClient_HasCap302(self)

    def HasCapNotify(self):
        return _znc_core.CClient_HasCapNotify(self)

    def HasAwayNotify(self):
        return _znc_core.CClient_HasAwayNotify(self)

    def HasAccountNotify(self):
        return _znc_core.CClient_HasAccountNotify(self)

    def HasExtendedJoin(self):
        return _znc_core.CClient_HasExtendedJoin(self)

    def HasNamesx(self):
        return _znc_core.CClient_HasNamesx(self)

    def HasUHNames(self):
        return _znc_core.CClient_HasUHNames(self)

    def IsAway(self):
        return _znc_core.CClient_IsAway(self)

    def HasServerTime(self):
        return _znc_core.CClient_HasServerTime(self)

    def HasBatch(self):
        return _znc_core.CClient_HasBatch(self)

    def HasEchoMessage(self):
        return _znc_core.CClient_HasEchoMessage(self)

    def HasSelfMessage(self):
        return _znc_core.CClient_HasSelfMessage(self)

    @staticmethod
    def IsValidIdentifier(sIdentifier):
        return _znc_core.CClient_IsValidIdentifier(sIdentifier)

    def UserCommand(self, sLine):
        return _znc_core.CClient_UserCommand(self, sLine)

    def UserPortCommand(self, sLine):
        return _znc_core.CClient_UserPortCommand(self, sLine)

    def StatusCTCP(self, sCommand):
        return _znc_core.CClient_StatusCTCP(self, sCommand)

    def BouncedOff(self):
        return _znc_core.CClient_BouncedOff(self)

    def IsAttached(self):
        return _znc_core.CClient_IsAttached(self)

    def IsPlaybackActive(self):
        return _znc_core.CClient_IsPlaybackActive(self)

    def SetPlaybackActive(self, bActive):
        return _znc_core.CClient_SetPlaybackActive(self, bActive)

    def PutIRC(self, sLine):
        return _znc_core.CClient_PutIRC(self, sLine)

    def PutClientRaw(self, sLine):
        return _znc_core.CClient_PutClientRaw(self, sLine)

    def PutClient(self, *args):
        return _znc_core.CClient_PutClient(self, *args)

    def PutStatus(self, *args):
        return _znc_core.CClient_PutStatus(self, *args)

    def PutStatusNotice(self, sLine):
        return _znc_core.CClient_PutStatusNotice(self, sLine)

    def PutModule(self, sModule, sLine):
        return _znc_core.CClient_PutModule(self, sModule, sLine)

    def PutModNotice(self, sModule, sLine):
        return _znc_core.CClient_PutModNotice(self, sModule, sLine)

    def IsCapEnabled(self, sCap):
        return _znc_core.CClient_IsCapEnabled(self, sCap)

    def IsTagEnabled(self, sTag):
        return _znc_core.CClient_IsTagEnabled(self, sTag)

    def SetTagSupport(self, sTag, bState):
        return _znc_core.CClient_SetTagSupport(self, sTag, bState)

    def NotifyServerDependentCap(self, sCap, bValue, sValue):
        return _znc_core.CClient_NotifyServerDependentCap(self, sCap, bValue, sValue)

    def ReadLine(self, sData):
        return _znc_core.CClient_ReadLine(self, sData)

    def SendMotd(self):
        return _znc_core.CClient_SendMotd(self)

    def HelpUser(self, *args):
        return _znc_core.CClient_HelpUser(self, *args)

    def AuthUser(self):
        return _znc_core.CClient_AuthUser(self)

    def Connected(self):
        return _znc_core.CClient_Connected(self)

    def Timeout(self):
        return _znc_core.CClient_Timeout(self)

    def Disconnected(self):
        return _znc_core.CClient_Disconnected(self)

    def ConnectionRefused(self):
        return _znc_core.CClient_ConnectionRefused(self)

    def ReachedMaxBuffer(self):
        return _znc_core.CClient_ReachedMaxBuffer(self)

    def SetNick(self, s):
        return _znc_core.CClient_SetNick(self, s)

    def SetAway(self, bAway):
        return _znc_core.CClient_SetAway(self, bAway)

    def GetUser(self):
        return _znc_core.CClient_GetUser(self)

    def SetNetwork(self, pNetwork, bDisconnect=True, bReconnect=True):
        return _znc_core.CClient_SetNetwork(self, pNetwork, bDisconnect, bReconnect)

    def GetNetwork(self):
        return _znc_core.CClient_GetNetwork(self)

    def GetClients(self):
        return _znc_core.CClient_GetClients(self)

    def GetIRCSock(self, *args):
        return _znc_core.CClient_GetIRCSock(self, *args)

    def GetFullName(self):
        return _znc_core.CClient_GetFullName(self)

# Register CClient in _znc_core:
_znc_core.CClient_swigregister(CClient)
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):
        _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):
        return _znc_core.CIRCSock_ReadLine(self, sData)

    def Connected(self):
        return _znc_core.CIRCSock_Connected(self)

    def Disconnected(self):
        return _znc_core.CIRCSock_Disconnected(self)

    def ConnectionRefused(self):
        return _znc_core.CIRCSock_ConnectionRefused(self)

    def SockError(self, iErrno, sDescription):
        return _znc_core.CIRCSock_SockError(self, iErrno, sDescription)

    def Timeout(self):
        return _znc_core.CIRCSock_Timeout(self)

    def ReachedMaxBuffer(self):
        return _znc_core.CIRCSock_ReachedMaxBuffer(self)

    def PutIRCRaw(self, sLine):
        return _znc_core.CIRCSock_PutIRCRaw(self, sLine)

    def PutIRC(self, *args):
        return _znc_core.CIRCSock_PutIRC(self, *args)

    def PutIRCQuick(self, sLine):
        return _znc_core.CIRCSock_PutIRCQuick(self, sLine)

    def ResetChans(self):
        return _znc_core.CIRCSock_ResetChans(self)

    def Quit(self, *args):
        return _znc_core.CIRCSock_Quit(self, *args)

    def PauseCap(self):
        return _znc_core.CIRCSock_PauseCap(self)

    def ResumeCap(self):
        return _znc_core.CIRCSock_ResumeCap(self)

    def IsTagEnabled(self, sTag):
        return _znc_core.CIRCSock_IsTagEnabled(self, sTag)

    def SetTagSupport(self, sTag, bState):
        return _znc_core.CIRCSock_SetTagSupport(self, sTag, bState)

    def SetPass(self, s):
        return _znc_core.CIRCSock_SetPass(self, s)

    def GetMaxNickLen(self):
        return _znc_core.CIRCSock_GetMaxNickLen(self)

    def GetModeType(self, cMode):
        return _znc_core.CIRCSock_GetModeType(self, cMode)

    def GetPermFromMode(self, cMode):
        return _znc_core.CIRCSock_GetPermFromMode(self, cMode)

    def GetChanModes(self):
        return _znc_core.CIRCSock_GetChanModes(self)

    def IsPermChar(self, c):
        return _znc_core.CIRCSock_IsPermChar(self, c)

    def IsPermMode(self, c):
        return _znc_core.CIRCSock_IsPermMode(self, c)

    def GetPerms(self):
        return _znc_core.CIRCSock_GetPerms(self)

    def GetPermModes(self):
        return _znc_core.CIRCSock_GetPermModes(self)

    def GetNickMask(self):
        return _znc_core.CIRCSock_GetNickMask(self)

    def GetNick(self):
        return _znc_core.CIRCSock_GetNick(self)

    def GetPass(self):
        return _znc_core.CIRCSock_GetPass(self)

    def GetNetwork(self):
        return _znc_core.CIRCSock_GetNetwork(self)

    def HasNamesx(self):
        return _znc_core.CIRCSock_HasNamesx(self)

    def HasUHNames(self):
        return _znc_core.CIRCSock_HasUHNames(self)

    def HasAwayNotify(self):
        return _znc_core.CIRCSock_HasAwayNotify(self)

    def HasAccountNotify(self):
        return _znc_core.CIRCSock_HasAccountNotify(self)

    def HasExtendedJoin(self):
        return _znc_core.CIRCSock_HasExtendedJoin(self)

    def HasServerTime(self):
        return _znc_core.CIRCSock_HasServerTime(self)

    def GetUserModes(self):
        return _znc_core.CIRCSock_GetUserModes(self)

    def IsAuthed(self):
        return _znc_core.CIRCSock_IsAuthed(self)

    def GetAcceptedCaps(self):
        return _znc_core.CIRCSock_GetAcceptedCaps(self)

    def IsCapAccepted(self, sCap):
        return _znc_core.CIRCSock_IsCapAccepted(self, sCap)

    def GetCapLsValue(self, *args):
        return _znc_core.CIRCSock_GetCapLsValue(self, *args)

    def GetISupport(self, *args):
        return _znc_core.CIRCSock_GetISupport(self, *args)

    @staticmethod
    def IsFloodProtected(fRate):
        return _znc_core.CIRCSock_IsFloodProtected(fRate)

# Register CIRCSock in _znc_core:
_znc_core.CIRCSock_swigregister(CIRCSock)
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, sBindHost, sURIPrefix, bSSL, eAddr, eAccept):
        _znc_core.CListener_swiginit(self, _znc_core.new_CListener(uPort, sBindHost, sURIPrefix, bSSL, eAddr, eAccept))
    __swig_destroy__ = _znc_core.delete_CListener

    def IsSSL(self):
        return _znc_core.CListener_IsSSL(self)

    def GetAddrType(self):
        return _znc_core.CListener_GetAddrType(self)

    def GetPort(self):
        return _znc_core.CListener_GetPort(self)

    def GetBindHost(self):
        return _znc_core.CListener_GetBindHost(self)

    def GetRealListener(self):
        return _znc_core.CListener_GetRealListener(self)

    def GetURIPrefix(self):
        return _znc_core.CListener_GetURIPrefix(self)

    def GetAcceptType(self):
        return _znc_core.CListener_GetAcceptType(self)

    def SetAcceptType(self, eType):
        return _znc_core.CListener_SetAcceptType(self, eType)

    def Listen(self):
        return _znc_core.CListener_Listen(self)

    def ResetRealListener(self):
        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):
        _znc_core.CRealListener_swiginit(self, _znc_core.new_CRealListener(listener))
    __swig_destroy__ = _znc_core.delete_CRealListener

    def ConnectionFrom(self, sHost, uPort):
        return _znc_core.CRealListener_ConnectionFrom(self, sHost, uPort)

    def GetSockObj(self, sHost, uPort):
        return _znc_core.CRealListener_GetSockObj(self, sHost, uPort)

    def SockError(self, iErrno, sDescription):
        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, uPort, eAcceptType, sURIPrefix):
        _znc_core.CIncomingConnection_swiginit(self, _znc_core.new_CIncomingConnection(sHostname, uPort, eAcceptType, sURIPrefix))
    __swig_destroy__ = _znc_core.delete_CIncomingConnection

    def ReadLine(self, sData):
        return _znc_core.CIncomingConnection_ReadLine(self, sData)

    def ReachedMaxBuffer(self):
        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, len):
        return _znc_core.CHTTPSock_ReadData(self, data, len)

    def ReadLine(self, sData):
        return _znc_core.CHTTPSock_ReadLine(self, sData)

    def Connected(self):
        return _znc_core.CHTTPSock_Connected(self)

    def GetSockObj(self, sHost, uPort):
        return _znc_core.CHTTPSock_GetSockObj(self, sHost, uPort)

    def ForceLogin(self):
        return _znc_core.CHTTPSock_ForceLogin(self)

    def OnLogin(self, sUser, sPass, bBasic):
        return _znc_core.CHTTPSock_OnLogin(self, sUser, sPass, bBasic)

    def OnPageRequest(self, sURI):
        return _znc_core.CHTTPSock_OnPageRequest(self, sURI)

    def PrintFile(self, *args):
        return _znc_core.CHTTPSock_PrintFile(self, *args)

    def CheckPost(self):
        return _znc_core.CHTTPSock_CheckPost(self)

    def SentHeader(self):
        return _znc_core.CHTTPSock_SentHeader(self)

    def PrintHeader(self, *args):
        return _znc_core.CHTTPSock_PrintHeader(self, *args)

    def AddHeader(self, sName, sValue):
        return _znc_core.CHTTPSock_AddHeader(self, sName, sValue)

    def SetContentType(self, sContentType):
        return _znc_core.CHTTPSock_SetContentType(self, sContentType)

    def PrintNotFound(self):
        return _znc_core.CHTTPSock_PrintNotFound(self)

    def Redirect(self, sURL):
        return _znc_core.CHTTPSock_Redirect(self, sURL)

    def PrintErrorPage(self, uStatusId, sStatusMsg, sMessage):
        return _znc_core.CHTTPSock_PrintErrorPage(self, uStatusId, sStatusMsg, sMessage)

    @staticmethod
    def ParseParams(sParams, msvsParams):
        return _znc_core.CHTTPSock_ParseParams(sParams, msvsParams)

    def ParseURI(self):
        return _znc_core.CHTTPSock_ParseURI(self)

    def GetPage(self):
        return _znc_core.CHTTPSock_GetPage(self)

    @staticmethod
    def GetDate(tm=0):
        return _znc_core.CHTTPSock_GetDate(tm)

    def GetRemoteIP(self):
        return _znc_core.CHTTPSock_GetRemoteIP(self)

    def GetRequestCookie(self, sKey):
        return _znc_core.CHTTPSock_GetRequestCookie(self, sKey)

    def SendCookie(self, sKey, sValue):
        return _znc_core.CHTTPSock_SendCookie(self, sKey, sValue)

    def SetDocRoot(self, s):
        return _znc_core.CHTTPSock_SetDocRoot(self, s)

    def SetLoggedIn(self, b):
        return _znc_core.CHTTPSock_SetLoggedIn(self, b)

    def GetPath(self):
        return _znc_core.CHTTPSock_GetPath(self)

    def IsLoggedIn(self):
        return _znc_core.CHTTPSock_IsLoggedIn(self)

    def GetDocRoot(self):
        return _znc_core.CHTTPSock_GetDocRoot(self)

    def GetUser(self):
        return _znc_core.CHTTPSock_GetUser(self)

    def GetPass(self):
        return _znc_core.CHTTPSock_GetPass(self)

    def GetParamString(self):
        return _znc_core.CHTTPSock_GetParamString(self)

    def GetContentType(self):
        return _znc_core.CHTTPSock_GetContentType(self)

    def GetURI(self):
        return _znc_core.CHTTPSock_GetURI(self)

    def GetURIPrefix(self):
        return _znc_core.CHTTPSock_GetURIPrefix(self)

    def IsPost(self):
        return _znc_core.CHTTPSock_IsPost(self)

    def GetParam(self, *args):
        return _znc_core.CHTTPSock_GetParam(self, *args)

    def GetRawParam(self, sName, bPost=True):
        return _znc_core.CHTTPSock_GetRawParam(self, sName, bPost)

    def HasParam(self, sName, bPost=True):
        return _znc_core.CHTTPSock_HasParam(self, sName, bPost)

    def GetParams(self, bPost=True):
        return _znc_core.CHTTPSock_GetParams(self, bPost)

    def GetParamValues(self, *args):
        return _znc_core.CHTTPSock_GetParamValues(self, *args)

# Register CHTTPSock in _znc_core:
_znc_core.CHTTPSock_swigregister(CHTTPSock)
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, sName, sArgs, sOutput):
        return _znc_core.CTemplateTagHandler_HandleVar(self, Tmpl, sName, sArgs, sOutput)

    def HandleTag(self, Tmpl, sName, sArgs, sOutput):
        return _znc_core.CTemplateTagHandler_HandleTag(self, Tmpl, sName, sArgs, sOutput)

    def HandleIf(self, Tmpl, sName, sArgs, sOutput):
        return _znc_core.CTemplateTagHandler_HandleIf(self, Tmpl, sName, sArgs, sOutput)

    def HandleValue(self, Tmpl, sValue, msOptions):
        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):
        return _znc_core.CTemplateOptions_Parse(self, sLine)

    def GetEscapeFrom(self):
        return _znc_core.CTemplateOptions_GetEscapeFrom(self)

    def GetEscapeTo(self):
        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=True):
        return _znc_core.CTemplateLoopContext_SetHasData(self, b)

    def SetName(self, s):
        return _znc_core.CTemplateLoopContext_SetName(self, s)

    def SetRowIndex(self, u):
        return _znc_core.CTemplateLoopContext_SetRowIndex(self, u)

    def IncRowIndex(self):
        return _znc_core.CTemplateLoopContext_IncRowIndex(self)

    def DecRowIndex(self):
        return _znc_core.CTemplateLoopContext_DecRowIndex(self)

    def SetFilePosition(self, u):
        return _znc_core.CTemplateLoopContext_SetFilePosition(self, u)

    def HasData(self):
        return _znc_core.CTemplateLoopContext_HasData(self)

    def GetName(self):
        return _znc_core.CTemplateLoopContext_GetName(self)

    def GetFilePosition(self):
        return _znc_core.CTemplateLoopContext_GetFilePosition(self)

    def GetRowIndex(self):
        return _znc_core.CTemplateLoopContext_GetRowIndex(self)

    def GetRowCount(self):
        return _znc_core.CTemplateLoopContext_GetRowCount(self)

    def GetRows(self):
        return _znc_core.CTemplateLoopContext_GetRows(self)

    def GetNextRow(self):
        return _znc_core.CTemplateLoopContext_GetNextRow(self)

    def GetCurRow(self):
        return _znc_core.CTemplateLoopContext_GetCurRow(self)

    def GetRow(self, uIndex):
        return _znc_core.CTemplateLoopContext_GetRow(self, uIndex)

    def GetValue(self, sName, bFromIf=False):
        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):
        return _znc_core.CTemplate_AddTagHandler(self, spTagHandler)

    def GetTagHandlers(self):
        return _znc_core.CTemplate_GetTagHandlers(self)

    def ResolveLiteral(self, sString):
        return _znc_core.CTemplate_ResolveLiteral(self, sString)

    def Init(self):
        return _znc_core.CTemplate_Init(self)

    def GetParent(self, bRoot):
        return _znc_core.CTemplate_GetParent(self, bRoot)

    def ExpandFile(self, sFilename, bFromInc=False):
        return _znc_core.CTemplate_ExpandFile(self, sFilename, bFromInc)

    def SetFile(self, sFileName):
        return _znc_core.CTemplate_SetFile(self, sFileName)

    def SetPath(self, sPath):
        return _znc_core.CTemplate_SetPath(self, sPath)

    def MakePath(self, sPath):
        return _znc_core.CTemplate_MakePath(self, sPath)

    def PrependPath(self, sPath, bIncludesOnly=False):
        return _znc_core.CTemplate_PrependPath(self, sPath, bIncludesOnly)

    def AppendPath(self, sPath, bIncludesOnly=False):
        return _znc_core.CTemplate_AppendPath(self, sPath, bIncludesOnly)

    def RemovePath(self, sPath):
        return _znc_core.CTemplate_RemovePath(self, sPath)

    def ClearPaths(self):
        return _znc_core.CTemplate_ClearPaths(self)

    def PrintString(self, sRet):
        return _znc_core.CTemplate_PrintString(self, sRet)

    def Print(self, *args):
        return _znc_core.CTemplate_Print(self, *args)

    def ValidIf(self, sArgs):
        return _znc_core.CTemplate_ValidIf(self, sArgs)

    def ValidExpr(self, sExpr):
        return _znc_core.CTemplate_ValidExpr(self, sExpr)

    def IsTrue(self, sName):
        return _znc_core.CTemplate_IsTrue(self, sName)

    def HasLoop(self, sName):
        return _znc_core.CTemplate_HasLoop(self, sName)

    def GetValue(self, sName, bFromIf=False):
        return _znc_core.CTemplate_GetValue(self, sName, bFromIf)

    def AddRow(self, sName):
        return _znc_core.CTemplate_AddRow(self, sName)

    def GetRow(self, sName, uIndex):
        return _znc_core.CTemplate_GetRow(self, sName, uIndex)

    def GetLoop(self, sName):
        return _znc_core.CTemplate_GetLoop(self, sName)

    def DelCurLoopContext(self):
        return _znc_core.CTemplate_DelCurLoopContext(self)

    def GetCurLoopContext(self):
        return _znc_core.CTemplate_GetCurLoopContext(self)

    def GetCurTemplate(self):
        return _znc_core.CTemplate_GetCurTemplate(self)

    def GetFileName(self):
        return _znc_core.CTemplate_GetFileName(self)

    def set(self, key, value):
        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):
        _znc_core.CZNCTagHandler_swiginit(self, _znc_core.new_CZNCTagHandler(pWebSock))
    __swig_destroy__ = _znc_core.delete_CZNCTagHandler

    def HandleTag(self, Tmpl, sName, sArgs, sOutput):
        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, sIP):
        _znc_core.CWebSession_swiginit(self, _znc_core.new_CWebSession(sId, sIP))
    __swig_destroy__ = _znc_core.delete_CWebSession

    def GetId(self):
        return _znc_core.CWebSession_GetId(self)

    def GetIP(self):
        return _znc_core.CWebSession_GetIP(self)

    def GetUser(self):
        return _znc_core.CWebSession_GetUser(self)

    def GetLastActive(self):
        return _znc_core.CWebSession_GetLastActive(self)

    def IsLoggedIn(self):
        return _znc_core.CWebSession_IsLoggedIn(self)

    def IsAdmin(self):
        return _znc_core.CWebSession_IsAdmin(self)

    def UpdateLastActive(self):
        return _znc_core.CWebSession_UpdateLastActive(self)

    def SetUser(self, p):
        return _znc_core.CWebSession_SetUser(self, p)

    def ClearMessageLoops(self):
        return _znc_core.CWebSession_ClearMessageLoops(self)

    def FillMessageLoops(self, Tmpl):
        return _znc_core.CWebSession_FillMessageLoops(self, Tmpl)

    def AddError(self, sMessage):
        return _znc_core.CWebSession_AddError(self, sMessage)

    def AddSuccess(self, sMessage):
        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):
        return _znc_core.CWebSubPage_SetName(self, s)

    def SetTitle(self, s):
        return _znc_core.CWebSubPage_SetTitle(self, s)

    def AddParam(self, sName, sValue):
        return _znc_core.CWebSubPage_AddParam(self, sName, sValue)

    def RequiresAdmin(self):
        return _znc_core.CWebSubPage_RequiresAdmin(self)

    def GetName(self):
        return _znc_core.CWebSubPage_GetName(self)

    def GetTitle(self):
        return _znc_core.CWebSubPage_GetTitle(self)

    def GetParams(self):
        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=5000):
        _znc_core.CWebSessionMap_swiginit(self, _znc_core.new_CWebSessionMap(uTTL))

    def FinishUserSessions(self, User):
        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):
        _znc_core.CWebSock_swiginit(self, _znc_core.new_CWebSock(sURIPrefix))
    __swig_destroy__ = _znc_core.delete_CWebSock

    def ForceLogin(self):
        return _znc_core.CWebSock_ForceLogin(self)

    def OnLogin(self, sUser, sPass, bBasic):
        return _znc_core.CWebSock_OnLogin(self, sUser, sPass, bBasic)

    def OnPageRequest(self, sURI):
        return _znc_core.CWebSock_OnPageRequest(self, sURI)

    def PrintTemplate(self, sPageName, sPageRet, pModule=None):
        return _znc_core.CWebSock_PrintTemplate(self, sPageName, sPageRet, pModule)

    def PrintStaticFile(self, sPath, sPageRet, pModule=None):
        return _znc_core.CWebSock_PrintStaticFile(self, sPath, sPageRet, pModule)

    def FindTmpl(self, pModule, sName):
        return _znc_core.CWebSock_FindTmpl(self, pModule, sName)

    def PrintErrorPage(self, sMessage):
        return _znc_core.CWebSock_PrintErrorPage(self, sMessage)

    def GetSession(self):
        return _znc_core.CWebSock_GetSession(self)

    def GetSockObj(self, sHost, uPort):
        return _znc_core.CWebSock_GetSockObj(self, sHost, uPort)

    @staticmethod
    def GetSkinPath(sSkinName):
        return _znc_core.CWebSock_GetSkinPath(sSkinName)

    def GetAvailSkins(self, vRet):
        return _znc_core.CWebSock_GetAvailSkins(self, vRet)

    def GetSkinName(self):
        return _znc_core.CWebSock_GetSkinName(self)

    def GetRequestCookie(self, sKey):
        return _znc_core.CWebSock_GetRequestCookie(self, sKey)

    def SendCookie(self, sKey, sValue):
        return _znc_core.CWebSock_SendCookie(self, sKey, sValue)

    @staticmethod
    def FinishUserSessions(User):
        return _znc_core.CWebSock_FinishUserSessions(User)

    def GetCSRFCheck(self):
        return _znc_core.CWebSock_GetCSRFCheck(self)

    def ValidateCSRFCheck(self, sURI):
        return _znc_core.CWebSock_ValidateCSRFCheck(self, sURI)

# Register CWebSock in _znc_core:
_znc_core.CWebSock_swigregister(CWebSock)
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):
        return _znc_core.CZNC_DeleteUsers(self)

    def Loop(self):
        return _znc_core.CZNC_Loop(self)

    def WritePidFile(self, iPid):
        return _znc_core.CZNC_WritePidFile(self, iPid)

    def DeletePidFile(self):
        return _znc_core.CZNC_DeletePidFile(self)

    def WaitForChildLock(self):
        return _znc_core.CZNC_WaitForChildLock(self)

    def IsHostAllowed(self, sHostMask):
        return _znc_core.CZNC_IsHostAllowed(self, sHostMask)

    def AllowConnectionFrom(self, sIP):
        return _znc_core.CZNC_AllowConnectionFrom(self, sIP)

    def InitDirs(self, sArgvPath, sDataDir):
        return _znc_core.CZNC_InitDirs(self, sArgvPath, sDataDir)

    def OnBoot(self):
        return _znc_core.CZNC_OnBoot(self)

    def ExpandConfigPath(self, sConfigFile, bAllowMkDir=True):
        return _znc_core.CZNC_ExpandConfigPath(self, sConfigFile, bAllowMkDir)

    def WriteNewConfig(self, sConfigFile):
        return _znc_core.CZNC_WriteNewConfig(self, sConfigFile)

    def WriteConfig(self):
        return _znc_core.CZNC_WriteConfig(self)

    def ParseConfig(self, sConfig, sError):
        return _znc_core.CZNC_ParseConfig(self, sConfig, sError)

    def RehashConfig(self, sError):
        return _znc_core.CZNC_RehashConfig(self, sError)

    def BackupConfigOnce(self, sSuffix):
        return _znc_core.CZNC_BackupConfigOnce(self, sSuffix)

    @staticmethod
    def GetVersion():
        return _znc_core.CZNC_GetVersion()

    @staticmethod
    def GetTag(bIncludeVersion=True, bHTML=False):
        return _znc_core.CZNC_GetTag(bIncludeVersion, bHTML)

    @staticmethod
    def GetCompileOptionsString():
        return _znc_core.CZNC_GetCompileOptionsString()

    def GetUptime(self):
        return _znc_core.CZNC_GetUptime(self)

    def ClearBindHosts(self):
        return _znc_core.CZNC_ClearBindHosts(self)

    def AddBindHost(self, sHost):
        return _znc_core.CZNC_AddBindHost(self, sHost)

    def RemBindHost(self, sHost):
        return _znc_core.CZNC_RemBindHost(self, sHost)

    def ClearTrustedProxies(self):
        return _znc_core.CZNC_ClearTrustedProxies(self)

    def AddTrustedProxy(self, sHost):
        return _znc_core.CZNC_AddTrustedProxy(self, sHost)

    def RemTrustedProxy(self, sHost):
        return _znc_core.CZNC_RemTrustedProxy(self, sHost)

    def Broadcast(self, sMessage, bAdminOnly=False, pSkipUser=None, pSkipClient=None):
        return _znc_core.CZNC_Broadcast(self, sMessage, bAdminOnly, pSkipUser, pSkipClient)

    def AddBytesRead(self, u):
        return _znc_core.CZNC_AddBytesRead(self, u)

    def AddBytesWritten(self, u):
        return _znc_core.CZNC_AddBytesWritten(self, u)

    def BytesRead(self):
        return _znc_core.CZNC_BytesRead(self)

    def BytesWritten(self):
        return _znc_core.CZNC_BytesWritten(self)

    def GetTrafficStats(self, Users, ZNC, Total):
        return _znc_core.CZNC_GetTrafficStats(self, Users, ZNC, Total)

    def GetNetworkTrafficStats(self, sUsername, Total):
        return _znc_core.CZNC_GetNetworkTrafficStats(self, sUsername, Total)

    def AuthUser(self, AuthClass):
        return _znc_core.CZNC_AuthUser(self, AuthClass)

    def SetConfigState(self, e):
        return _znc_core.CZNC_SetConfigState(self, e)

    def SetSkinName(self, s):
        return _znc_core.CZNC_SetSkinName(self, s)

    def SetStatusPrefix(self, s):
        return _znc_core.CZNC_SetStatusPrefix(self, s)

    def SetMaxBufferSize(self, i):
        return _znc_core.CZNC_SetMaxBufferSize(self, i)

    def SetAnonIPLimit(self, i):
        return _znc_core.CZNC_SetAnonIPLimit(self, i)

    def SetServerThrottle(self, i):
        return _znc_core.CZNC_SetServerThrottle(self, i)

    def SetProtectWebSessions(self, b):
        return _znc_core.CZNC_SetProtectWebSessions(self, b)

    def SetHideVersion(self, b):
        return _znc_core.CZNC_SetHideVersion(self, b)

    def SetAuthOnlyViaModule(self, b):
        return _znc_core.CZNC_SetAuthOnlyViaModule(self, b)

    def SetConnectDelay(self, i):
        return _znc_core.CZNC_SetConnectDelay(self, i)

    def SetSSLCiphers(self, sCiphers):
        return _znc_core.CZNC_SetSSLCiphers(self, sCiphers)

    def SetSSLProtocols(self, sProtocols):
        return _znc_core.CZNC_SetSSLProtocols(self, sProtocols)

    def SetSSLCertFile(self, sFile):
        return _znc_core.CZNC_SetSSLCertFile(self, sFile)

    def SetConfigWriteDelay(self, i):
        return _znc_core.CZNC_SetConfigWriteDelay(self, i)

    def GetConfigState(self):
        return _znc_core.CZNC_GetConfigState(self)

    def GetManager(self, *args):
        return _znc_core.CZNC_GetManager(self, *args)

    def GetModules(self):
        return _znc_core.CZNC_GetModules(self)

    def GetSkinName(self):
        return _znc_core.CZNC_GetSkinName(self)

    def GetStatusPrefix(self):
        return _znc_core.CZNC_GetStatusPrefix(self)

    def GetCurPath(self):
        return _znc_core.CZNC_GetCurPath(self)

    def GetHomePath(self):
        return _znc_core.CZNC_GetHomePath(self)

    def GetZNCPath(self):
        return _znc_core.CZNC_GetZNCPath(self)

    def GetConfPath(self, bAllowMkDir=True):
        return _znc_core.CZNC_GetConfPath(self, bAllowMkDir)

    def GetUserPath(self):
        return _znc_core.CZNC_GetUserPath(self)

    def GetModPath(self):
        return _znc_core.CZNC_GetModPath(self)

    def GetPemLocation(self):
        return _znc_core.CZNC_GetPemLocation(self)

    def GetKeyLocation(self):
        return _znc_core.CZNC_GetKeyLocation(self)

    def GetDHParamLocation(self):
        return _znc_core.CZNC_GetDHParamLocation(self)

    def GetConfigFile(self):
        return _znc_core.CZNC_GetConfigFile(self)

    def WritePemFile(self):
        return _znc_core.CZNC_WritePemFile(self)

    def GetBindHosts(self):
        return _znc_core.CZNC_GetBindHosts(self)

    def GetTrustedProxies(self):
        return _znc_core.CZNC_GetTrustedProxies(self)

    def GetListeners(self):
        return _znc_core.CZNC_GetListeners(self)

    def TimeStarted(self):
        return _znc_core.CZNC_TimeStarted(self)

    def GetMaxBufferSize(self):
        return _znc_core.CZNC_GetMaxBufferSize(self)

    def GetAnonIPLimit(self):
        return _znc_core.CZNC_GetAnonIPLimit(self)

    def GetConnectDelay(self):
        return _znc_core.CZNC_GetConnectDelay(self)

    def GetProtectWebSessions(self):
        return _znc_core.CZNC_GetProtectWebSessions(self)

    def GetHideVersion(self):
        return _znc_core.CZNC_GetHideVersion(self)

    def GetAuthOnlyViaModule(self):
        return _znc_core.CZNC_GetAuthOnlyViaModule(self)

    def GetSSLCiphers(self):
        return _znc_core.CZNC_GetSSLCiphers(self)

    def GetSSLProtocols(self):
        return _znc_core.CZNC_GetSSLProtocols(self)

    def GetDisabledSSLProtocols(self):
        return _znc_core.CZNC_GetDisabledSSLProtocols(self)

    def GetSSLCertFile(self):
        return _znc_core.CZNC_GetSSLCertFile(self)

    @staticmethod
    def GetAvailableSSLProtocols():
        return _znc_core.CZNC_GetAvailableSSLProtocols()

    def GetConfigWriteDelay(self):
        return _znc_core.CZNC_GetConfigWriteDelay(self)

    @staticmethod
    def CreateInstance():
        return _znc_core.CZNC_CreateInstance()

    @staticmethod
    def Get():
        return _znc_core.CZNC_Get()

    @staticmethod
    def DestroyInstance():
        return _znc_core.CZNC_DestroyInstance()

    def FindUser(self, sUsername):
        return _znc_core.CZNC_FindUser(self, sUsername)

    def FindModule(self, *args):
        return _znc_core.CZNC_FindModule(self, *args)

    def UpdateModule(self, sModule):
        return _znc_core.CZNC_UpdateModule(self, sModule)

    def DeleteUser(self, sUsername):
        return _znc_core.CZNC_DeleteUser(self, sUsername)

    def AddUser(self, pUser, sErrorRet, bStartup=False):
        return _znc_core.CZNC_AddUser(self, pUser, sErrorRet, bStartup)

    def GetUserMap(self):
        return _znc_core.CZNC_GetUserMap(self)

    def FindListener(self, uPort, BindHost, eAddr):
        return _znc_core.CZNC_FindListener(self, uPort, BindHost, eAddr)

    def AddListener(self, *args):
        return _znc_core.CZNC_AddListener(self, *args)

    def DelListener(self, arg2):
        return _znc_core.CZNC_DelListener(self, arg2)

    def SetMotd(self, sMessage):
        return _znc_core.CZNC_SetMotd(self, sMessage)

    def AddMotd(self, sMessage):
        return _znc_core.CZNC_AddMotd(self, sMessage)

    def ClearMotd(self):
        return _znc_core.CZNC_ClearMotd(self)

    def GetMotd(self):
        return _znc_core.CZNC_GetMotd(self)

    def AddServerThrottle(self, sName):
        return _znc_core.CZNC_AddServerThrottle(self, sName)

    def GetServerThrottle(self, *args):
        return _znc_core.CZNC_GetServerThrottle(self, *args)

    def AddNetworkToQueue(self, pNetwork):
        return _znc_core.CZNC_AddNetworkToQueue(self, pNetwork)

    def GetConnectionQueue(self):
        return _znc_core.CZNC_GetConnectionQueue(self)

    def EnableConnectQueue(self):
        return _znc_core.CZNC_EnableConnectQueue(self)

    def DisableConnectQueue(self):
        return _znc_core.CZNC_DisableConnectQueue(self)

    def PauseConnectQueue(self):
        return _znc_core.CZNC_PauseConnectQueue(self)

    def ResumeConnectQueue(self):
        return _znc_core.CZNC_ResumeConnectQueue(self)

    def ForceEncoding(self):
        return _znc_core.CZNC_ForceEncoding(self)

    def UnforceEncoding(self):
        return _znc_core.CZNC_UnforceEncoding(self)

    def IsForcingEncoding(self):
        return _znc_core.CZNC_IsForcingEncoding(self)

    def FixupEncoding(self, sEncoding):
        return _znc_core.CZNC_FixupEncoding(self, sEncoding)

    def LeakConnectQueueTimer(self, pTimer):
        return _znc_core.CZNC_LeakConnectQueueTimer(self, pTimer)

    def DisableConfigTimer(self):
        return _znc_core.CZNC_DisableConfigTimer(self)

    @staticmethod
    def DumpConfig(Config):
        return _znc_core.CZNC_DumpConfig(Config)

    def GetUserMap_(self):
        return _znc_core.CZNC_GetUserMap_(self)

# Register CZNC in _znc_core:
_znc_core.CZNC_swigregister(CZNC)
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):
        return _znc_core.CServer_GetName(self)

    def GetPort(self):
        return _znc_core.CServer_GetPort(self)

    def GetPass(self):
        return _znc_core.CServer_GetPass(self)

    def IsSSL(self):
        return _znc_core.CServer_IsSSL(self)

    def GetString(self, bIncludePassword=True):
        return _znc_core.CServer_GetString(self, bIncludePassword)

    @staticmethod
    def IsValidHostName(sHostName):
        return _znc_core.CServer_IsValidHostName(sHostName)

# Register CServer in _znc_core:
_znc_core.CServer_swigregister(CServer)
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):
        return _znc_core.CDebug_SetStdoutIsTTY(b)

    @staticmethod
    def StdoutIsTTY():
        return _znc_core.CDebug_StdoutIsTTY()

    @staticmethod
    def SetDebug(b):
        return _znc_core.CDebug_SetDebug(b)

    @staticmethod
    def Debug():
        return _znc_core.CDebug_Debug()

    @staticmethod
    def Filter(sUnfilteredLine):
        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)
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):
        return _znc_core.CExecSock_Execute(self, sExec)

    def Kill(self, iSignal):
        return _znc_core.CExecSock_Kill(self, iSignal)
    __swig_destroy__ = _znc_core.delete_CExecSock

    def popen2(self, iReadFD, iWriteFD, sCommand):
        return _znc_core.CExecSock_popen2(self, iReadFD, iWriteFD, sCommand)

    def close2(self, iPid, iReadFD, iWriteFD):
        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, mssParams):
        return _znc_core.CBufLine_ToMessage(self, Client, mssParams)

    def GetLine(self, Client, mssParams):
        return _znc_core.CBufLine_GetLine(self, Client, mssParams)

    def UpdateTime(self):
        return _znc_core.CBufLine_UpdateTime(self)

    def Equals(self, Format):
        return _znc_core.CBufLine_Equals(self, Format)

    def SetFormat(self, sFormat):
        return _znc_core.CBufLine_SetFormat(self, sFormat)

    def SetText(self, sText):
        return _znc_core.CBufLine_SetText(self, sText)

    def SetTime(self, ts):
        return _znc_core.CBufLine_SetTime(self, ts)

    def SetTags(self, mssTags):
        return _znc_core.CBufLine_SetTags(self, mssTags)

    def GetCommand(self):
        return _znc_core.CBufLine_GetCommand(self)

    def GetFormat(self):
        return _znc_core.CBufLine_GetFormat(self)

    def GetText(self):
        return _znc_core.CBufLine_GetText(self)

    def GetTime(self):
        return _znc_core.CBufLine_GetTime(self)

    def GetTags(self):
        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=100):
        _znc_core.CBuffer_swiginit(self, _znc_core.new_CBuffer(uLineCount))
    __swig_destroy__ = _znc_core.delete_CBuffer

    def AddLine(self, *args):
        return _znc_core.CBuffer_AddLine(self, *args)

    def UpdateLine(self, *args):
        return _znc_core.CBuffer_UpdateLine(self, *args)

    def UpdateExactLine(self, *args):
        return _znc_core.CBuffer_UpdateExactLine(self, *args)

    def GetBufLine(self, uIdx):
        return _znc_core.CBuffer_GetBufLine(self, uIdx)

    def GetLine(self, *args):
        return _znc_core.CBuffer_GetLine(self, *args)

    def Size(self):
        return _znc_core.CBuffer_Size(self)

    def IsEmpty(self):
        return _znc_core.CBuffer_IsEmpty(self)

    def Clear(self):
        return _znc_core.CBuffer_Clear(self)

    def SetLineCount(self, u, bForce=False):
        return _znc_core.CBuffer_SetLineCount(self, u, bForce)

    def GetLineCount(self):
        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):
        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, pNetwork, sModName, sDataPath, eType, pyObj, pModPython):
        _znc_core.CPyModule_swiginit(self, _znc_core.new_CPyModule(pUser, pNetwork, sModName, sDataPath, eType, pyObj, pModPython))

    def GetPyObj(self):
        return _znc_core.CPyModule_GetPyObj(self)

    def GetNewPyObj(self):
        return _znc_core.CPyModule_GetNewPyObj(self)

    def DeletePyModule(self):
        return _znc_core.CPyModule_DeletePyModule(self)

    def GetPyExceptionStr(self):
        return _znc_core.CPyModule_GetPyExceptionStr(self)

    def GetModPython(self):
        return _znc_core.CPyModule_GetModPython(self)

    def OnBoot(self):
        return _znc_core.CPyModule_OnBoot(self)

    def WebRequiresLogin(self):
        return _znc_core.CPyModule_WebRequiresLogin(self)

    def WebRequiresAdmin(self):
        return _znc_core.CPyModule_WebRequiresAdmin(self)

    def GetWebMenuTitle(self):
        return _znc_core.CPyModule_GetWebMenuTitle(self)

    def OnWebPreRequest(self, WebSock, sPageName):
        return _znc_core.CPyModule_OnWebPreRequest(self, WebSock, sPageName)

    def OnWebRequest(self, WebSock, sPageName, Tmpl):
        return _znc_core.CPyModule_OnWebRequest(self, WebSock, sPageName, Tmpl)

    def ValidateWebRequestCSRFCheck(self, WebSock, sPageName):
        return _znc_core.CPyModule_ValidateWebRequestCSRFCheck(self, WebSock, sPageName)

    def GetSubPages(self):
        return _znc_core.CPyModule_GetSubPages(self)

    def OnPreRehash(self):
        return _znc_core.CPyModule_OnPreRehash(self)

    def OnPostRehash(self):
        return _znc_core.CPyModule_OnPostRehash(self)

    def OnIRCDisconnected(self):
        return _znc_core.CPyModule_OnIRCDisconnected(self)

    def OnIRCConnected(self):
        return _znc_core.CPyModule_OnIRCConnected(self)

    def OnIRCConnecting(self, pIRCSock):
        return _znc_core.CPyModule_OnIRCConnecting(self, pIRCSock)

    def OnIRCConnectionError(self, pIRCSock):
        return _znc_core.CPyModule_OnIRCConnectionError(self, pIRCSock)

    def OnIRCRegistration(self, sPass, sNick, sIdent, sRealName):
        return _znc_core.CPyModule_OnIRCRegistration(self, sPass, sNick, sIdent, sRealName)

    def OnBroadcast(self, sMessage):
        return _znc_core.CPyModule_OnBroadcast(self, sMessage)

    def OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange):
        return _znc_core.CPyModule_OnChanPermission2(self, pOpNick, Nick, Channel, uMode, bAdded, bNoChange)

    def OnOp2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CPyModule_OnOp2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDeop2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CPyModule_OnDeop2(self, pOpNick, Nick, Channel, bNoChange)

    def OnVoice2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CPyModule_OnVoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnDevoice2(self, pOpNick, Nick, Channel, bNoChange):
        return _znc_core.CPyModule_OnDevoice2(self, pOpNick, Nick, Channel, bNoChange)

    def OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange):
        return _znc_core.CPyModule_OnMode2(self, pOpNick, Channel, uMode, sArg, bAdded, bNoChange)

    def OnRawMode2(self, pOpNick, Channel, sModes, sArgs):
        return _znc_core.CPyModule_OnRawMode2(self, pOpNick, Channel, sModes, sArgs)

    def OnRaw(self, sLine):
        return _znc_core.CPyModule_OnRaw(self, sLine)

    def OnStatusCommand(self, sCommand):
        return _znc_core.CPyModule_OnStatusCommand(self, sCommand)

    def OnModCommand(self, sCommand):
        return _znc_core.CPyModule_OnModCommand(self, sCommand)

    def OnModNotice(self, sMessage):
        return _znc_core.CPyModule_OnModNotice(self, sMessage)

    def OnModCTCP(self, sMessage):
        return _znc_core.CPyModule_OnModCTCP(self, sMessage)

    def OnQuit(self, Nick, sMessage, vChans):
        return _znc_core.CPyModule_OnQuit(self, Nick, sMessage, vChans)

    def OnNick(self, Nick, sNewNick, vChans):
        return _znc_core.CPyModule_OnNick(self, Nick, sNewNick, vChans)

    def OnKick(self, OpNick, sKickedNick, Channel, sMessage):
        return _znc_core.CPyModule_OnKick(self, OpNick, sKickedNick, Channel, sMessage)

    def OnJoining(self, Channel):
        return _znc_core.CPyModule_OnJoining(self, Channel)

    def OnJoin(self, Nick, Channel):
        return _znc_core.CPyModule_OnJoin(self, Nick, Channel)

    def OnPart(self, Nick, Channel, sMessage):
        return _znc_core.CPyModule_OnPart(self, Nick, Channel, sMessage)

    def OnInvite(self, Nick, sChan):
        return _znc_core.CPyModule_OnInvite(self, Nick, sChan)

    def OnChanBufferStarting(self, Chan, Client):
        return _znc_core.CPyModule_OnChanBufferStarting(self, Chan, Client)

    def OnChanBufferEnding(self, Chan, Client):
        return _znc_core.CPyModule_OnChanBufferEnding(self, Chan, Client)

    def OnChanBufferPlayLine(self, Chan, Client, sLine):
        return _znc_core.CPyModule_OnChanBufferPlayLine(self, Chan, Client, sLine)

    def OnPrivBufferPlayLine(self, Client, sLine):
        return _znc_core.CPyModule_OnPrivBufferPlayLine(self, Client, sLine)

    def OnClientLogin(self):
        return _znc_core.CPyModule_OnClientLogin(self)

    def OnClientDisconnect(self):
        return _znc_core.CPyModule_OnClientDisconnect(self)

    def OnUserRaw(self, sLine):
        return _znc_core.CPyModule_OnUserRaw(self, sLine)

    def OnUserCTCPReply(self, sTarget, sMessage):
        return _znc_core.CPyModule_OnUserCTCPReply(self, sTarget, sMessage)

    def OnUserCTCP(self, sTarget, sMessage):
        return _znc_core.CPyModule_OnUserCTCP(self, sTarget, sMessage)

    def OnUserAction(self, sTarget, sMessage):
        return _znc_core.CPyModule_OnUserAction(self, sTarget, sMessage)

    def OnUserMsg(self, sTarget, sMessage):
        return _znc_core.CPyModule_OnUserMsg(self, sTarget, sMessage)

    def OnUserNotice(self, sTarget, sMessage):
        return _znc_core.CPyModule_OnUserNotice(self, sTarget, sMessage)

    def OnUserJoin(self, sChannel, sKey):
        return _znc_core.CPyModule_OnUserJoin(self, sChannel, sKey)

    def OnUserPart(self, sChannel, sMessage):
        return _znc_core.CPyModule_OnUserPart(self, sChannel, sMessage)

    def OnUserTopic(self, sChannel, sTopic):
        return _znc_core.CPyModule_OnUserTopic(self, sChannel, sTopic)

    def OnUserTopicRequest(self, sChannel):
        return _znc_core.CPyModule_OnUserTopicRequest(self, sChannel)

    def OnUserQuit(self, sMessage):
        return _znc_core.CPyModule_OnUserQuit(self, sMessage)

    def OnCTCPReply(self, Nick, sMessage):
        return _znc_core.CPyModule_OnCTCPReply(self, Nick, sMessage)

    def OnPrivCTCP(self, Nick, sMessage):
        return _znc_core.CPyModule_OnPrivCTCP(self, Nick, sMessage)

    def OnChanCTCP(self, Nick, Channel, sMessage):
        return _znc_core.CPyModule_OnChanCTCP(self, Nick, Channel, sMessage)

    def OnPrivAction(self, Nick, sMessage):
        return _znc_core.CPyModule_OnPrivAction(self, Nick, sMessage)

    def OnChanAction(self, Nick, Channel, sMessage):
        return _znc_core.CPyModule_OnChanAction(self, Nick, Channel, sMessage)

    def OnPrivMsg(self, Nick, sMessage):
        return _znc_core.CPyModule_OnPrivMsg(self, Nick, sMessage)

    def OnChanMsg(self, Nick, Channel, sMessage):
        return _znc_core.CPyModule_OnChanMsg(self, Nick, Channel, sMessage)

    def OnPrivNotice(self, Nick, sMessage):
        return _znc_core.CPyModule_OnPrivNotice(self, Nick, sMessage)

    def OnChanNotice(self, Nick, Channel, sMessage):
        return _znc_core.CPyModule_OnChanNotice(self, Nick, Channel, sMessage)

    def OnTopic(self, Nick, Channel, sTopic):
        return _znc_core.CPyModule_OnTopic(self, Nick, Channel, sTopic)

    def OnServerCapAvailable(self, sCap):
        return _znc_core.CPyModule_OnServerCapAvailable(self, sCap)

    def OnServerCap302Available(self, sCap, sValue):
        return _znc_core.CPyModule_OnServerCap302Available(self, sCap, sValue)

    def OnServerCapResult(self, sCap, bSuccess):
        return _znc_core.CPyModule_OnServerCapResult(self, sCap, bSuccess)

    def OnClientAttached(self):
        return _znc_core.CPyModule_OnClientAttached(self)

    def OnClientDetached(self):
        return _znc_core.CPyModule_OnClientDetached(self)

    def OnTimerAutoJoin(self, Channel):
        return _znc_core.CPyModule_OnTimerAutoJoin(self, Channel)

    def OnEmbeddedWebRequest(self, arg2, arg3, arg4):
        return _znc_core.CPyModule_OnEmbeddedWebRequest(self, arg2, arg3, arg4)

    def OnAddNetwork(self, Network, sErrorRet):
        return _znc_core.CPyModule_OnAddNetwork(self, Network, sErrorRet)

    def OnDeleteNetwork(self, Network):
        return _znc_core.CPyModule_OnDeleteNetwork(self, Network)

    def OnSendToClient(self, sLine, Client):
        return _znc_core.CPyModule_OnSendToClient(self, sLine, Client)

    def OnSendToIRC(self, sLine):
        return _znc_core.CPyModule_OnSendToIRC(self, sLine)

    def OnRawMessage(self, Message):
        return _znc_core.CPyModule_OnRawMessage(self, Message)

    def OnNumericMessage(self, Message):
        return _znc_core.CPyModule_OnNumericMessage(self, Message)

    def OnQuitMessage(self, Message, vChans):
        return _znc_core.CPyModule_OnQuitMessage(self, Message, vChans)

    def OnNickMessage(self, Message, vChans):
        return _znc_core.CPyModule_OnNickMessage(self, Message, vChans)

    def OnKickMessage(self, Message):
        return _znc_core.CPyModule_OnKickMessage(self, Message)

    def OnJoinMessage(self, Message):
        return _znc_core.CPyModule_OnJoinMessage(self, Message)

    def OnPartMessage(self, Message):
        return _znc_core.CPyModule_OnPartMessage(self, Message)

    def OnChanBufferPlayMessage(self, Message):
        return _znc_core.CPyModule_OnChanBufferPlayMessage(self, Message)

    def OnPrivBufferPlayMessage(self, Message):
        return _znc_core.CPyModule_OnPrivBufferPlayMessage(self, Message)

    def OnUserRawMessage(self, Message):
        return _znc_core.CPyModule_OnUserRawMessage(self, Message)

    def OnUserCTCPReplyMessage(self, Message):
        return _znc_core.CPyModule_OnUserCTCPReplyMessage(self, Message)

    def OnUserCTCPMessage(self, Message):
        return _znc_core.CPyModule_OnUserCTCPMessage(self, Message)

    def OnUserActionMessage(self, Message):
        return _znc_core.CPyModule_OnUserActionMessage(self, Message)

    def OnUserTextMessage(self, Message):
        return _znc_core.CPyModule_OnUserTextMessage(self, Message)

    def OnUserNoticeMessage(self, Message):
        return _znc_core.CPyModule_OnUserNoticeMessage(self, Message)

    def OnUserJoinMessage(self, Message):
        return _znc_core.CPyModule_OnUserJoinMessage(self, Message)

    def OnUserPartMessage(self, Message):
        return _znc_core.CPyModule_OnUserPartMessage(self, Message)

    def OnUserTopicMessage(self, Message):
        return _znc_core.CPyModule_OnUserTopicMessage(self, Message)

    def OnUserQuitMessage(self, Message):
        return _znc_core.CPyModule_OnUserQuitMessage(self, Message)

    def OnCTCPReplyMessage(self, Message):
        return _znc_core.CPyModule_OnCTCPReplyMessage(self, Message)

    def OnPrivCTCPMessage(self, Message):
        return _znc_core.CPyModule_OnPrivCTCPMessage(self, Message)

    def OnChanCTCPMessage(self, Message):
        return _znc_core.CPyModule_OnChanCTCPMessage(self, Message)

    def OnPrivActionMessage(self, Message):
        return _znc_core.CPyModule_OnPrivActionMessage(self, Message)

    def OnChanActionMessage(self, Message):
        return _znc_core.CPyModule_OnChanActionMessage(self, Message)

    def OnPrivTextMessage(self, Message):
        return _znc_core.CPyModule_OnPrivTextMessage(self, Message)

    def OnChanTextMessage(self, Message):
        return _znc_core.CPyModule_OnChanTextMessage(self, Message)

    def OnPrivNoticeMessage(self, Message):
        return _znc_core.CPyModule_OnPrivNoticeMessage(self, Message)

    def OnChanNoticeMessage(self, Message):
        return _znc_core.CPyModule_OnChanNoticeMessage(self, Message)

    def OnTopicMessage(self, Message):
        return _znc_core.CPyModule_OnTopicMessage(self, Message)

    def OnSendToClientMessage(self, Message):
        return _znc_core.CPyModule_OnSendToClientMessage(self, Message)

    def OnSendToIRCMessage(self, Message):
        return _znc_core.CPyModule_OnSendToIRCMessage(self, Message)

    def OnAddUser(self, User, sErrorRet):
        return _znc_core.CPyModule_OnAddUser(self, User, sErrorRet)

    def OnDeleteUser(self, User):
        return _znc_core.CPyModule_OnDeleteUser(self, User)

    def OnClientConnect(self, pSock, sHost, uPort):
        return _znc_core.CPyModule_OnClientConnect(self, pSock, sHost, uPort)

    def OnFailedLogin(self, sUsername, sRemoteIP):
        return _znc_core.CPyModule_OnFailedLogin(self, sUsername, sRemoteIP)

    def OnUnknownUserRaw(self, pClient, sLine):
        return _znc_core.CPyModule_OnUnknownUserRaw(self, pClient, sLine)

    def OnUnknownUserRawMessage(self, Message):
        return _znc_core.CPyModule_OnUnknownUserRawMessage(self, Message)

    def IsClientCapSupported(self, pClient, sCap, bState):
        return _znc_core.CPyModule_IsClientCapSupported(self, pClient, sCap, bState)

    def OnClientCapRequest(self, pClient, sCap, bState):
        return _znc_core.CPyModule_OnClientCapRequest(self, pClient, sCap, bState)

    def OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg):
        return _znc_core.CPyModule_OnModuleLoading(self, sModName, sArgs, eType, bSuccess, sRetMsg)

    def OnModuleUnloading(self, pModule, bSuccess, sRetMsg):
        return _znc_core.CPyModule_OnModuleUnloading(self, pModule, bSuccess, sRetMsg)

    def OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg):
        return _znc_core.CPyModule_OnGetModInfo(self, ModInfo, sModule, bSuccess, sRetMsg)

    def OnGetAvailableMods(self, ssMods, eType):
        return _znc_core.CPyModule_OnGetAvailableMods(self, ssMods, eType)

    def OnClientCapLs(self, pClient, ssCaps):
        return _znc_core.CPyModule_OnClientCapLs(self, pClient, ssCaps)

    def OnLoginAttempt(self, Auth):
        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):
    return _znc_core.AsPyModule(p)

def CreatePyModule(pUser, pNetwork, sModName, sDataPath, eType, pyObj, pModPython):
    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, uInterval, uCycles, sLabel, sDescription, pyObj):
        _znc_core.CPyTimer_swiginit(self, _znc_core.new_CPyTimer(pModule, uInterval, uCycles, sLabel, sDescription, pyObj))

    def RunJob(self):
        return _znc_core.CPyTimer_RunJob(self)

    def GetPyObj(self):
        return _znc_core.CPyTimer_GetPyObj(self)

    def GetNewPyObj(self):
        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, uInterval, uCycles, sLabel, sDescription, pyObj):
    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, pyObj):
        _znc_core.CPySocket_swiginit(self, _znc_core.new_CPySocket(pModule, pyObj))

    def GetPyObj(self):
        return _znc_core.CPySocket_GetPyObj(self)

    def GetNewPyObj(self):
        return _znc_core.CPySocket_GetNewPyObj(self)
    __swig_destroy__ = _znc_core.delete_CPySocket

    def Connected(self):
        return _znc_core.CPySocket_Connected(self)

    def Disconnected(self):
        return _znc_core.CPySocket_Disconnected(self)

    def Timeout(self):
        return _znc_core.CPySocket_Timeout(self)

    def ConnectionRefused(self):
        return _znc_core.CPySocket_ConnectionRefused(self)

    def ReadData(self, data, len):
        return _znc_core.CPySocket_ReadData(self, data, len)

    def ReadLine(self, sLine):
        return _znc_core.CPySocket_ReadLine(self, sLine)

    def GetSockObj(self, sHost, uPort):
        return _znc_core.CPySocket_GetSockObj(self, sHost, uPort)

# Register CPySocket in _znc_core:
_znc_core.CPySocket_swigregister(CPySocket)

def CreatePySocket(pModule, pyObj):
    return _znc_core.CreatePySocket(pModule, pyObj)

def HaveIPv6_():
    return _znc_core.HaveIPv6_()

def HaveSSL_():
    return _znc_core.HaveSSL_()

def HaveCharset_():
    return _znc_core.HaveCharset_()

def GetSOMAXCONN():
    return _znc_core.GetSOMAXCONN()

def GetVersionMajor():
    return _znc_core.GetVersionMajor()

def GetVersionMinor():
    return _znc_core.GetVersionMinor()

def GetVersion():
    return _znc_core.GetVersion()

def GetVersionExtra():
    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):
        return _znc_core.MCString_iter_plusplus(self)

    def get(self):
        return _znc_core.MCString_iter_get(self)

    def is_end(self, m):
        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):
        _znc_core.CModulesIter_swiginit(self, _znc_core.new_CModulesIter(pModules))

    def plusplus(self):
        return _znc_core.CModulesIter_plusplus(self)

    def get(self):
        return _znc_core.CModulesIter_get(self)

    def is_end(self):
        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 CPyModCommand(CModCommand):
    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, sCmd, sArgs, sDesc, pyObj):
        _znc_core.CPyModCommand_swiginit(self, _znc_core.new_CPyModCommand(pModule, sCmd, sArgs, sDesc, pyObj))
    __swig_destroy__ = _znc_core.delete_CPyModCommand

    def GetModule(self):
        return _znc_core.CPyModCommand_GetModule(self)

# Register CPyModCommand in _znc_core:
_znc_core.CPyModCommand_swigregister(CPyModCommand)

def CreatePyModCommand(pModule, sCmd, sArgs, sDesc, pyObj):
    return _znc_core.CreatePyModCommand(pModule, sCmd, sArgs, sDesc, pyObj)
class CPyCapability(CCapability):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, serverCb, clientCb):
        _znc_core.CPyCapability_swiginit(self, _znc_core.new_CPyCapability(serverCb, clientCb))
    __swig_destroy__ = _znc_core.delete_CPyCapability

    def OnServerChangedSupport(self, pNetwork, bState):
        return _znc_core.CPyCapability_OnServerChangedSupport(self, pNetwork, bState)

    def OnClientChangedSupport(self, pClient, bState):
        return _znc_core.CPyCapability_OnClientChangedSupport(self, pClient, bState)

# Register CPyCapability in _znc_core:
_znc_core.CPyCapability_swigregister(CPyCapability)
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):
        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):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.VPair_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VPair___nonzero__(self)

    def __bool__(self):
        return _znc_core.VPair___bool__(self)

    def __len__(self):
        return _znc_core.VPair___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VPair___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VPair___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VPair___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VPair___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VPair___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VPair___setitem__(self, *args)

    def pop(self):
        return _znc_core.VPair_pop(self)

    def append(self, x):
        return _znc_core.VPair_append(self, x)

    def empty(self):
        return _znc_core.VPair_empty(self)

    def size(self):
        return _znc_core.VPair_size(self)

    def swap(self, v):
        return _znc_core.VPair_swap(self, v)

    def begin(self):
        return _znc_core.VPair_begin(self)

    def end(self):
        return _znc_core.VPair_end(self)

    def rbegin(self):
        return _znc_core.VPair_rbegin(self)

    def rend(self):
        return _znc_core.VPair_rend(self)

    def clear(self):
        return _znc_core.VPair_clear(self)

    def get_allocator(self):
        return _znc_core.VPair_get_allocator(self)

    def pop_back(self):
        return _znc_core.VPair_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VPair_push_back(self, x)

    def front(self):
        return _znc_core.VPair_front(self)

    def back(self):
        return _znc_core.VPair_back(self)

    def assign(self, n, x):
        return _znc_core.VPair_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VPair_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VPair_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VPair_reserve(self, n)

    def capacity(self):
        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 if _swig_python_version_info >= (3, 3) else collections.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):
        return _znc_core.VWebSubPages_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _znc_core.VWebSubPages___nonzero__(self)

    def __bool__(self):
        return _znc_core.VWebSubPages___bool__(self)

    def __len__(self):
        return _znc_core.VWebSubPages___len__(self)

    def __getslice__(self, i, j):
        return _znc_core.VWebSubPages___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _znc_core.VWebSubPages___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _znc_core.VWebSubPages___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _znc_core.VWebSubPages___delitem__(self, *args)

    def __getitem__(self, *args):
        return _znc_core.VWebSubPages___getitem__(self, *args)

    def __setitem__(self, *args):
        return _znc_core.VWebSubPages___setitem__(self, *args)

    def pop(self):
        return _znc_core.VWebSubPages_pop(self)

    def append(self, x):
        return _znc_core.VWebSubPages_append(self, x)

    def empty(self):
        return _znc_core.VWebSubPages_empty(self)

    def size(self):
        return _znc_core.VWebSubPages_size(self)

    def swap(self, v):
        return _znc_core.VWebSubPages_swap(self, v)

    def begin(self):
        return _znc_core.VWebSubPages_begin(self)

    def end(self):
        return _znc_core.VWebSubPages_end(self)

    def rbegin(self):
        return _znc_core.VWebSubPages_rbegin(self)

    def rend(self):
        return _znc_core.VWebSubPages_rend(self)

    def clear(self):
        return _znc_core.VWebSubPages_clear(self)

    def get_allocator(self):
        return _znc_core.VWebSubPages_get_allocator(self)

    def pop_back(self):
        return _znc_core.VWebSubPages_pop_back(self)

    def erase(self, *args):
        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):
        return _znc_core.VWebSubPages_push_back(self, x)

    def front(self):
        return _znc_core.VWebSubPages_front(self)

    def back(self):
        return _znc_core.VWebSubPages_back(self)

    def assign(self, n, x):
        return _znc_core.VWebSubPages_assign(self, n, x)

    def resize(self, *args):
        return _znc_core.VWebSubPages_resize(self, *args)

    def insert(self, *args):
        return _znc_core.VWebSubPages_insert(self, *args)

    def reserve(self, n):
        return _znc_core.VWebSubPages_reserve(self, n)

    def capacity(self):
        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, a, b):
    return _znc_core.VPair_Add2Str_(_self, a, b)

def CreateWebSubPage_(sName, sTitle, vParams, uFlags):
    return _znc_core.CreateWebSubPage_(sName, sTitle, vParams, uFlags)

