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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


import weakref

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__ = _client.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import seiscomp.system
import seiscomp.core
import seiscomp.logging
import seiscomp.config
import seiscomp.datamodel
import seiscomp.io
import seiscomp.math
import seiscomp.geo
import seiscomp.utils
class Packet(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Client::Packet class."""

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

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Packet
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Packet
        """
        return _client.Packet_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Packet
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Packet
        """
        return _client.Packet_ConstCast(*args)

    def __init__(self):
        r"""__init__(Packet self) -> Packet"""
        _client.Packet_swiginit(self, _client.new_Packet())
    Undefined = _client.Packet_Undefined
    
    Data = _client.Packet_Data
    
    Enter = _client.Packet_Enter
    
    Leave = _client.Packet_Leave
    
    Status = _client.Packet_Status
    
    Disconnected = _client.Packet_Disconnected
    
    type = property(_client.Packet_type_get, _client.Packet_type_set, doc=r"""type : Seiscomp::Client::Packet::Type""")
    headerContentEncoding = property(_client.Packet_headerContentEncoding_get, _client.Packet_headerContentEncoding_set, doc=r"""headerContentEncoding : std::string""")
    headerContentType = property(_client.Packet_headerContentType_get, _client.Packet_headerContentType_set, doc=r"""headerContentType : std::string""")
    sender = property(_client.Packet_sender_get, _client.Packet_sender_set, doc=r"""sender : std::string""")
    target = property(_client.Packet_target_get, _client.Packet_target_set, doc=r"""target : std::string""")
    subject = property(_client.Packet_subject_get, _client.Packet_subject_set, doc=r"""subject : std::string""")
    seqNo = property(_client.Packet_seqNo_get, _client.Packet_seqNo_set, doc=r"""seqNo : uint64_t""")
    payload = property(_client.Packet_payload_get, _client.Packet_payload_set, doc=r"""payload : std::string""")

    def swap(self, other):
        r"""swap(Packet self, Packet other) -> Packet"""
        return _client.Packet_swap(self, other)
    __swig_destroy__ = _client.delete_Packet

# Register Packet in _client:
_client.Packet_swigregister(Packet)

def Packet_Cast(*args):
    r"""
    Packet_Cast(BaseObject o) -> Packet
    Packet_Cast(Seiscomp::Core::BaseObjectPtr o) -> Packet
    """
    return _client.Packet_Cast(*args)

def Packet_ConstCast(*args):
    r"""
    Packet_ConstCast(BaseObject o) -> Packet
    Packet_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Packet
    """
    return _client.Packet_ConstCast(*args)

OK = _client.OK

InvalidURL = _client.InvalidURL

InvalidURLParameters = _client.InvalidURLParameters

InvalidProtocol = _client.InvalidProtocol

ContentEncodingRequired = _client.ContentEncodingRequired

ContentTypeRequired = _client.ContentTypeRequired

ContentEncodingUnknown = _client.ContentEncodingUnknown

ContentTypeUnknown = _client.ContentTypeUnknown

AlreadyConnected = _client.AlreadyConnected

NotConnected = _client.NotConnected

ConnectionClosedByPeer = _client.ConnectionClosedByPeer

SystemError = _client.SystemError

TimeoutError = _client.TimeoutError

NetworkError = _client.NetworkError

NetworkProtocolError = _client.NetworkProtocolError

DuplicateUsername = _client.DuplicateUsername

GroupDoesNotExist = _client.GroupDoesNotExist

InboxUnderflow = _client.InboxUnderflow

InboxOverflow = _client.InboxOverflow

OutboxOverflow = _client.OutboxOverflow

AlreadySubscribed = _client.AlreadySubscribed

NotSubscribed = _client.NotSubscribed

EncodingError = _client.EncodingError

DecodingError = _client.DecodingError

MissingGroup = _client.MissingGroup

InvalidMessageType = _client.InvalidMessageType

MessageTooLarge = _client.MessageTooLarge

Error = _client.Error

EResultQuantity = _client.EResultQuantity

class EResultNames(object):
    r"""Proxy of C++ Seiscomp::Client::EResultNames class."""

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

    def __init__(self):
        r"""__init__(EResultNames self) -> EResultNames"""
        _client.EResultNames_swiginit(self, _client.new_EResultNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _client.EResultNames_name(i)
    __swig_destroy__ = _client.delete_EResultNames

# Register EResultNames in _client:
_client.EResultNames_swigregister(EResultNames)

def EResultNames_name(i):
    r"""EResultNames_name(int i) -> char const *"""
    return _client.EResultNames_name(i)

class Protocol(object):
    r"""Proxy of C++ Seiscomp::Client::Protocol class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Identity = _client.Protocol_Identity
    
    Deflate = _client.Protocol_Deflate
    
    GZip = _client.Protocol_GZip
    
    LZ4 = _client.Protocol_LZ4
    
    EContentEncodingQuantity = _client.Protocol_EContentEncodingQuantity
    
    Binary = _client.Protocol_Binary
    
    JSON = _client.Protocol_JSON
    
    BSON = _client.Protocol_BSON
    
    XML = _client.Protocol_XML
    
    IMPORTED_XML = _client.Protocol_IMPORTED_XML
    
    Text = _client.Protocol_Text
    
    EContentTypeQuantity = _client.Protocol_EContentTypeQuantity
    
    Regular = _client.Protocol_Regular
    
    Transient = _client.Protocol_Transient
    
    Status = _client.Protocol_Status
    
    EMessageTypeQuantity = _client.Protocol_EMessageTypeQuantity
    
    __swig_destroy__ = _client.delete_Protocol

    def setMembershipInfo(self, enable):
        r"""setMembershipInfo(Protocol self, bool enable)"""
        return _client.Protocol_setMembershipInfo(self, enable)

    def connect(self, *args):
        r"""
        connect(Protocol self, char const * address, unsigned int timeoutMs, char const * clientName=None) -> Seiscomp::Client::Result
        connect(Protocol self, std::string const & address, unsigned int timeoutMs, std::string const & clientName=std::string()) -> Seiscomp::Client::Result
        """
        return _client.Protocol_connect(self, *args)

    def schemaVersion(self):
        r"""schemaVersion(Protocol self) -> Version"""
        return _client.Protocol_schemaVersion(self)

    def extendedParameters(self):
        r"""extendedParameters(Protocol self) -> Seiscomp::Client::Protocol::KeyValueStore const &"""
        return _client.Protocol_extendedParameters(self)

    def clientName(self):
        r"""clientName(Protocol self) -> std::string const &"""
        return _client.Protocol_clientName(self)

    def subscribe(self, group):
        r"""subscribe(Protocol self, std::string const & group) -> Seiscomp::Client::Result"""
        return _client.Protocol_subscribe(self, group)

    def unsubscribe(self, group):
        r"""unsubscribe(Protocol self, std::string const & group) -> Seiscomp::Client::Result"""
        return _client.Protocol_unsubscribe(self, group)

    def sendData(self, targetGroup, data, len, type, contentEncoding, contentType):
        r"""sendData(Protocol self, std::string const & targetGroup, char const * data, size_t len, Seiscomp::Client::Protocol::MessageType type, Seiscomp::Client::Protocol::ContentEncoding contentEncoding, Seiscomp::Client::Protocol::ContentType contentType) -> Seiscomp::Client::Result"""
        return _client.Protocol_sendData(self, targetGroup, data, len, type, contentEncoding, contentType)

    def sendMessage(self, *args):
        r"""sendMessage(Protocol self, std::string const & targetGroup, Message msg, Seiscomp::Client::Protocol::MessageType type=Regular, Seiscomp::Core::Optional< Seiscomp::Client::Protocol::ContentEncoding >::Impl contentEncoding=Unset, Seiscomp::Core::Optional< Seiscomp::Client::Protocol::ContentType >::Impl contentType=Unset) -> Seiscomp::Client::Result"""
        return _client.Protocol_sendMessage(self, *args)

    def recv(self):
        r"""recv(Protocol self) -> Packet"""
        return _client.Protocol_recv(self)

    def fetchInbox(self):
        r"""fetchInbox(Protocol self) -> Seiscomp::Client::Result"""
        return _client.Protocol_fetchInbox(self)

    def syncOutbox(self):
        r"""syncOutbox(Protocol self) -> Seiscomp::Client::Result"""
        return _client.Protocol_syncOutbox(self)

    def disconnect(self):
        r"""disconnect(Protocol self) -> Seiscomp::Client::Result"""
        return _client.Protocol_disconnect(self)

    def isConnected(self):
        r"""isConnected(Protocol self) -> bool"""
        return _client.Protocol_isConnected(self)

    def close(self):
        r"""close(Protocol self) -> Seiscomp::Client::Result"""
        return _client.Protocol_close(self)

    def setTimeout(self, milliseconds):
        r"""setTimeout(Protocol self, int milliseconds) -> Seiscomp::Client::Result"""
        return _client.Protocol_setTimeout(self, milliseconds)

    def groups(self):
        r"""groups(Protocol self) -> Seiscomp::Client::Protocol::Groups const &"""
        return _client.Protocol_groups(self)

    def erroneous(self):
        r"""erroneous(Protocol self) -> bool"""
        return _client.Protocol_erroneous(self)

    def lastErrorMessage(self):
        r"""lastErrorMessage(Protocol self) -> std::string const &"""
        return _client.Protocol_lastErrorMessage(self)

    def state(self):
        r"""state(Protocol self) -> Seiscomp::Client::Protocol::State const &"""
        return _client.Protocol_state(self)

    def inboxSize(self):
        r"""inboxSize(Protocol self) -> size_t"""
        return _client.Protocol_inboxSize(self)

    def outboxSize(self):
        r"""outboxSize(Protocol self) -> size_t"""
        return _client.Protocol_outboxSize(self)

    def setCertificate(self, cert):
        r"""setCertificate(Protocol self, std::string const & cert)"""
        return _client.Protocol_setCertificate(self, cert)

    @staticmethod
    def decode(*args):
        r"""
        decode(std::string const & blob, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type) -> Message
        decode(char const * blob, size_t blob_length, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type) -> Message
        """
        return _client.Protocol_decode(*args)

    @staticmethod
    def encode(blob, msg, encoding, type, schemaVersion):
        r"""encode(std::string & blob, Message msg, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type, int schemaVersion) -> bool"""
        return _client.Protocol_encode(blob, msg, encoding, type, schemaVersion)

# Register Protocol in _client:
_client.Protocol_swigregister(Protocol)
cvar = _client.cvar
Protocol.STATUS_GROUP = _client.cvar.Protocol_STATUS_GROUP
Protocol.LISTENER_GROUP = _client.cvar.Protocol_LISTENER_GROUP
Protocol.IMPORT_GROUP = _client.cvar.Protocol_IMPORT_GROUP

def Protocol_decode(*args):
    r"""
    Protocol_decode(std::string const & blob, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type) -> Message
    Protocol_decode(char const * blob, size_t blob_length, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type) -> Message
    """
    return _client.Protocol_decode(*args)

def Protocol_encode(blob, msg, encoding, type, schemaVersion):
    r"""Protocol_encode(std::string & blob, Message msg, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type, int schemaVersion) -> bool"""
    return _client.Protocol_encode(blob, msg, encoding, type, schemaVersion)

class Connection(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Client::Connection class."""

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

    def __init__(self, proto=None):
        r"""__init__(Connection self, Protocol proto=None) -> Connection"""
        _client.Connection_swiginit(self, _client.new_Connection(proto))
    __swig_destroy__ = _client.delete_Connection

    def setContentEncoding(self, enc):
        r"""setContentEncoding(Connection self, Seiscomp::Client::Protocol::ContentEncoding enc)"""
        return _client.Connection_setContentEncoding(self, enc)

    def setContentType(self, type):
        r"""setContentType(Connection self, Seiscomp::Client::Protocol::ContentType type)"""
        return _client.Connection_setContentType(self, type)

    def setSource(self, *args):
        r"""
        setSource(Connection self, char const * URL) -> Seiscomp::Client::Result
        setSource(Connection self, std::string const & URL) -> Seiscomp::Client::Result
        """
        return _client.Connection_setSource(self, *args)

    def source(self):
        r"""source(Connection self) -> std::string const &"""
        return _client.Connection_source(self)

    def setMembershipInfo(self, enable):
        r"""setMembershipInfo(Connection self, bool enable) -> Seiscomp::Client::Result"""
        return _client.Connection_setMembershipInfo(self, enable)

    def connect(self, clientName, primaryGroup, timeoutMs=3000):
        r"""connect(Connection self, std::string const & clientName, std::string const & primaryGroup, unsigned int timeoutMs=3000) -> Seiscomp::Client::Result"""
        return _client.Connection_connect(self, clientName, primaryGroup, timeoutMs)

    def disconnect(self):
        r"""disconnect(Connection self) -> Seiscomp::Client::Result"""
        return _client.Connection_disconnect(self)

    def isConnected(self):
        r"""isConnected(Connection self) -> bool"""
        return _client.Connection_isConnected(self)

    def reconnect(self):
        r"""reconnect(Connection self) -> Seiscomp::Client::Result"""
        return _client.Connection_reconnect(self)

    def close(self):
        r"""close(Connection self) -> Seiscomp::Client::Result"""
        return _client.Connection_close(self)

    def setTimeout(self, milliseconds):
        r"""setTimeout(Connection self, int milliseconds) -> Seiscomp::Client::Result"""
        return _client.Connection_setTimeout(self, milliseconds)

    def subscribe(self, *args):
        r"""
        subscribe(Connection self, char const * group) -> Seiscomp::Client::Result
        subscribe(Connection self, std::string const & group) -> Seiscomp::Client::Result
        """
        return _client.Connection_subscribe(self, *args)

    def unsubscribe(self, *args):
        r"""
        unsubscribe(Connection self, char const * group) -> Seiscomp::Client::Result
        unsubscribe(Connection self, std::string const & group) -> Seiscomp::Client::Result
        """
        return _client.Connection_unsubscribe(self, *args)

    def fetchInbox(self):
        r"""fetchInbox(Connection self) -> Seiscomp::Client::Result"""
        return _client.Connection_fetchInbox(self)

    def syncOutbox(self):
        r"""syncOutbox(Connection self) -> Seiscomp::Client::Result"""
        return _client.Connection_syncOutbox(self)

    def recv(self):
        r"""recv(Connection self) -> Message"""
        return _client.Connection_recv(self)

    def sendMessage(self, *args):
        r"""
        sendMessage(Connection self, Message msg) -> Seiscomp::Client::Result
        sendMessage(Connection self, std::string const & targetGroup, Message msg) -> Seiscomp::Client::Result
        """
        return _client.Connection_sendMessage(self, *args)

    def send(self, *args):
        r"""
        send(Connection self, Message msg) -> bool
        send(Connection self, std::string const & targetGroup, Message msg) -> bool
        """
        return _client.Connection_send(self, *args)

    def inboxSize(self):
        r"""inboxSize(Connection self) -> size_t"""
        return _client.Connection_inboxSize(self)

    def state(self):
        r"""state(Connection self) -> Seiscomp::Client::Protocol::State const *"""
        return _client.Connection_state(self)

    def lastError(self):
        r"""lastError(Connection self) -> Seiscomp::Client::Result"""
        return _client.Connection_lastError(self)

    def lastErrorMessage(self):
        r"""lastErrorMessage(Connection self) -> std::string const"""
        return _client.Connection_lastErrorMessage(self)

    def protocol(self):
        r"""protocol(Connection self) -> Protocol"""
        return _client.Connection_protocol(self)

    def setInfoCallback(self, arg2):
        r"""setInfoCallback(Connection self, Seiscomp::Client::Connection::InfoCallback arg2)"""
        return _client.Connection_setInfoCallback(self, arg2)

    def getInfo(self, timestamp, os):
        r"""getInfo(Connection self, Time timestamp, std::ostream & os)"""
        return _client.Connection_getInfo(self, timestamp, os)

    def setCertificate(self, cert):
        r"""setCertificate(Connection self, std::string const & cert) -> Seiscomp::Client::Result"""
        return _client.Connection_setCertificate(self, cert)

    def clientName(self):
        r"""clientName(Connection self) -> std::string const &"""
        return _client.Connection_clientName(self)

    def schemaVersion(self):
        r"""schemaVersion(Connection self) -> Version"""
        return _client.Connection_schemaVersion(self)

    def extendedParameters(self):
        r"""extendedParameters(Connection self) -> Seiscomp::Client::Protocol::KeyValueStore const *"""
        return _client.Connection_extendedParameters(self)

# Register Connection in _client:
_client.Connection_swigregister(Connection)

class ServiceRequestMessage(seiscomp.core.Message):
    r"""Proxy of C++ Seiscomp::Client::ServiceRequestMessage class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _client.ServiceRequestMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _client.ServiceRequestMessage_TypeInfo()

    def className(self):
        r"""className(ServiceRequestMessage self) -> char const *"""
        return _client.ServiceRequestMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(ServiceRequestMessage self) -> RTTI"""
        return _client.ServiceRequestMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ServiceRequestMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ServiceRequestMessage
        """
        return _client.ServiceRequestMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ServiceRequestMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ServiceRequestMessage
        """
        return _client.ServiceRequestMessage_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ServiceRequestMessage self, GenericArchive ar)"""
        return _client.ServiceRequestMessage_serialize(self, ar)

    def service(self):
        r"""service(ServiceRequestMessage self) -> char const *"""
        return _client.ServiceRequestMessage_service(self)
    __swig_destroy__ = _client.delete_ServiceRequestMessage

# Register ServiceRequestMessage in _client:
_client.ServiceRequestMessage_swigregister(ServiceRequestMessage)

def ServiceRequestMessage_ClassName():
    r"""ServiceRequestMessage_ClassName() -> char const *"""
    return _client.ServiceRequestMessage_ClassName()

def ServiceRequestMessage_TypeInfo():
    r"""ServiceRequestMessage_TypeInfo() -> RTTI"""
    return _client.ServiceRequestMessage_TypeInfo()

def ServiceRequestMessage_Cast(*args):
    r"""
    ServiceRequestMessage_Cast(BaseObject o) -> ServiceRequestMessage
    ServiceRequestMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ServiceRequestMessage
    """
    return _client.ServiceRequestMessage_Cast(*args)

def ServiceRequestMessage_ConstCast(*args):
    r"""
    ServiceRequestMessage_ConstCast(BaseObject o) -> ServiceRequestMessage
    ServiceRequestMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ServiceRequestMessage
    """
    return _client.ServiceRequestMessage_ConstCast(*args)

class ServiceProvideMessage(seiscomp.core.Message):
    r"""Proxy of C++ Seiscomp::Client::ServiceProvideMessage class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _client.ServiceProvideMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _client.ServiceProvideMessage_TypeInfo()

    def className(self):
        r"""className(ServiceProvideMessage self) -> char const *"""
        return _client.ServiceProvideMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(ServiceProvideMessage self) -> RTTI"""
        return _client.ServiceProvideMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ServiceProvideMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ServiceProvideMessage
        """
        return _client.ServiceProvideMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ServiceProvideMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ServiceProvideMessage
        """
        return _client.ServiceProvideMessage_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ServiceProvideMessage self, GenericArchive ar)"""
        return _client.ServiceProvideMessage_serialize(self, ar)

    def service(self):
        r"""service(ServiceProvideMessage self) -> char const *"""
        return _client.ServiceProvideMessage_service(self)

    def parameters(self):
        r"""parameters(ServiceProvideMessage self) -> char const *"""
        return _client.ServiceProvideMessage_parameters(self)

    def empty(self):
        r"""empty(ServiceProvideMessage self) -> bool"""
        return _client.ServiceProvideMessage_empty(self)
    __swig_destroy__ = _client.delete_ServiceProvideMessage

# Register ServiceProvideMessage in _client:
_client.ServiceProvideMessage_swigregister(ServiceProvideMessage)

def ServiceProvideMessage_ClassName():
    r"""ServiceProvideMessage_ClassName() -> char const *"""
    return _client.ServiceProvideMessage_ClassName()

def ServiceProvideMessage_TypeInfo():
    r"""ServiceProvideMessage_TypeInfo() -> RTTI"""
    return _client.ServiceProvideMessage_TypeInfo()

def ServiceProvideMessage_Cast(*args):
    r"""
    ServiceProvideMessage_Cast(BaseObject o) -> ServiceProvideMessage
    ServiceProvideMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ServiceProvideMessage
    """
    return _client.ServiceProvideMessage_Cast(*args)

def ServiceProvideMessage_ConstCast(*args):
    r"""
    ServiceProvideMessage_ConstCast(BaseObject o) -> ServiceProvideMessage
    ServiceProvideMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ServiceProvideMessage
    """
    return _client.ServiceProvideMessage_ConstCast(*args)

class DatabaseRequestMessage(ServiceRequestMessage):
    r"""Proxy of C++ Seiscomp::Client::DatabaseRequestMessage class."""

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

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _client.DatabaseRequestMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _client.DatabaseRequestMessage_TypeInfo()

    def className(self):
        r"""className(DatabaseRequestMessage self) -> char const *"""
        return _client.DatabaseRequestMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(DatabaseRequestMessage self) -> RTTI"""
        return _client.DatabaseRequestMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DatabaseRequestMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseRequestMessage
        """
        return _client.DatabaseRequestMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DatabaseRequestMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseRequestMessage
        """
        return _client.DatabaseRequestMessage_ConstCast(*args)

    def __init__(self, *args):
        r"""
        __init__(DatabaseRequestMessage self) -> DatabaseRequestMessage
        __init__(DatabaseRequestMessage self, char const * service) -> DatabaseRequestMessage
        """
        _client.DatabaseRequestMessage_swiginit(self, _client.new_DatabaseRequestMessage(*args))
    __swig_destroy__ = _client.delete_DatabaseRequestMessage

# Register DatabaseRequestMessage in _client:
_client.DatabaseRequestMessage_swigregister(DatabaseRequestMessage)

def DatabaseRequestMessage_ClassName():
    r"""DatabaseRequestMessage_ClassName() -> char const *"""
    return _client.DatabaseRequestMessage_ClassName()

def DatabaseRequestMessage_TypeInfo():
    r"""DatabaseRequestMessage_TypeInfo() -> RTTI"""
    return _client.DatabaseRequestMessage_TypeInfo()

def DatabaseRequestMessage_Cast(*args):
    r"""
    DatabaseRequestMessage_Cast(BaseObject o) -> DatabaseRequestMessage
    DatabaseRequestMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseRequestMessage
    """
    return _client.DatabaseRequestMessage_Cast(*args)

def DatabaseRequestMessage_ConstCast(*args):
    r"""
    DatabaseRequestMessage_ConstCast(BaseObject o) -> DatabaseRequestMessage
    DatabaseRequestMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseRequestMessage
    """
    return _client.DatabaseRequestMessage_ConstCast(*args)

class DatabaseProvideMessage(ServiceProvideMessage):
    r"""Proxy of C++ Seiscomp::Client::DatabaseProvideMessage class."""

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

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _client.DatabaseProvideMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _client.DatabaseProvideMessage_TypeInfo()

    def className(self):
        r"""className(DatabaseProvideMessage self) -> char const *"""
        return _client.DatabaseProvideMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(DatabaseProvideMessage self) -> RTTI"""
        return _client.DatabaseProvideMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DatabaseProvideMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseProvideMessage
        """
        return _client.DatabaseProvideMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DatabaseProvideMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseProvideMessage
        """
        return _client.DatabaseProvideMessage_ConstCast(*args)

    def __init__(self, *args):
        r"""
        __init__(DatabaseProvideMessage self) -> DatabaseProvideMessage
        __init__(DatabaseProvideMessage self, char const * service, char const * params) -> DatabaseProvideMessage
        """
        _client.DatabaseProvideMessage_swiginit(self, _client.new_DatabaseProvideMessage(*args))

    def database(self):
        r"""database(DatabaseProvideMessage self) -> DatabaseInterface"""
        return _client.DatabaseProvideMessage_database(self)
    __swig_destroy__ = _client.delete_DatabaseProvideMessage

# Register DatabaseProvideMessage in _client:
_client.DatabaseProvideMessage_swigregister(DatabaseProvideMessage)

def DatabaseProvideMessage_ClassName():
    r"""DatabaseProvideMessage_ClassName() -> char const *"""
    return _client.DatabaseProvideMessage_ClassName()

def DatabaseProvideMessage_TypeInfo():
    r"""DatabaseProvideMessage_TypeInfo() -> RTTI"""
    return _client.DatabaseProvideMessage_TypeInfo()

def DatabaseProvideMessage_Cast(*args):
    r"""
    DatabaseProvideMessage_Cast(BaseObject o) -> DatabaseProvideMessage
    DatabaseProvideMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseProvideMessage
    """
    return _client.DatabaseProvideMessage_Cast(*args)

def DatabaseProvideMessage_ConstCast(*args):
    r"""
    DatabaseProvideMessage_ConstCast(BaseObject o) -> DatabaseProvideMessage
    DatabaseProvideMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseProvideMessage
    """
    return _client.DatabaseProvideMessage_ConstCast(*args)

class RunningAverage(object):
    r"""Proxy of C++ Seiscomp::Client::RunningAverage class."""

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

    def __init__(self, timeSpanInSeconds):
        r"""__init__(RunningAverage self, int timeSpanInSeconds) -> RunningAverage"""
        _client.RunningAverage_swiginit(self, _client.new_RunningAverage(timeSpanInSeconds))

    def timeSpan(self):
        r"""timeSpan(RunningAverage self) -> int"""
        return _client.RunningAverage_timeSpan(self)

    def push(self, time, count=1):
        r"""push(RunningAverage self, Time time, size_t count=1)"""
        return _client.RunningAverage_push(self, time, count)

    def count(self, time):
        r"""count(RunningAverage self, Time time) -> int"""
        return _client.RunningAverage_count(self, time)

    def value(self, time):
        r"""value(RunningAverage self, Time time) -> double"""
        return _client.RunningAverage_value(self, time)

    def last(self):
        r"""last(RunningAverage self) -> Time"""
        return _client.RunningAverage_last(self)

    def dumpBins(self):
        r"""dumpBins(RunningAverage self)"""
        return _client.RunningAverage_dumpBins(self)
    __swig_destroy__ = _client.delete_RunningAverage

# Register RunningAverage in _client:
_client.RunningAverage_swigregister(RunningAverage)

class ObjectMonitor(object):
    r"""Proxy of C++ Seiscomp::Client::ObjectMonitor class."""

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

    def __init__(self, timeSpanInSeconds):
        r"""__init__(ObjectMonitor self, int timeSpanInSeconds) -> ObjectMonitor"""
        _client.ObjectMonitor_swiginit(self, _client.new_ObjectMonitor(timeSpanInSeconds))
    __swig_destroy__ = _client.delete_ObjectMonitor

    def add(self, *args):
        r"""add(ObjectMonitor self, std::string const & name, std::string const & channel="") -> RunningAverage"""
        return _client.ObjectMonitor_add(self, *args)

    def update(self, time):
        r"""update(ObjectMonitor self, Time time)"""
        return _client.ObjectMonitor_update(self, time)

    def begin(self):
        r"""begin(ObjectMonitor self) -> Seiscomp::Client::ObjectMonitor::const_iterator"""
        return _client.ObjectMonitor_begin(self)

    def end(self):
        r"""end(ObjectMonitor self) -> Seiscomp::Client::ObjectMonitor::const_iterator"""
        return _client.ObjectMonitor_end(self)

    def size(self):
        r"""size(ObjectMonitor self) -> size_t"""
        return _client.ObjectMonitor_size(self)

# Register ObjectMonitor in _client:
_client.ObjectMonitor_swigregister(ObjectMonitor)

STARTED = _client.STARTED

FINISHED = _client.FINISHED

EApplicationStatusQuantity = _client.EApplicationStatusQuantity

class EApplicationStatusNames(object):
    r"""Proxy of C++ Seiscomp::Client::EApplicationStatusNames class."""

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

    def __init__(self):
        r"""__init__(EApplicationStatusNames self) -> EApplicationStatusNames"""
        _client.EApplicationStatusNames_swiginit(self, _client.new_EApplicationStatusNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _client.EApplicationStatusNames_name(i)
    __swig_destroy__ = _client.delete_EApplicationStatusNames

# Register EApplicationStatusNames in _client:
_client.EApplicationStatusNames_swigregister(EApplicationStatusNames)

def EApplicationStatusNames_name(i):
    r"""EApplicationStatusNames_name(int i) -> char const *"""
    return _client.EApplicationStatusNames_name(i)

class ApplicationStatusMessage(seiscomp.core.Message):
    r"""Proxy of C++ Seiscomp::Client::ApplicationStatusMessage class."""

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

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _client.ApplicationStatusMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _client.ApplicationStatusMessage_TypeInfo()

    def className(self):
        r"""className(ApplicationStatusMessage self) -> char const *"""
        return _client.ApplicationStatusMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(ApplicationStatusMessage self) -> RTTI"""
        return _client.ApplicationStatusMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ApplicationStatusMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ApplicationStatusMessage
        """
        return _client.ApplicationStatusMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ApplicationStatusMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ApplicationStatusMessage
        """
        return _client.ApplicationStatusMessage_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ApplicationStatusMessage self, GenericArchive ar)"""
        return _client.ApplicationStatusMessage_serialize(self, ar)

    def __init__(self, *args):
        r"""
        __init__(ApplicationStatusMessage self) -> ApplicationStatusMessage
        __init__(ApplicationStatusMessage self, std::string const & module, Seiscomp::Client::ApplicationStatus status) -> ApplicationStatusMessage
        __init__(ApplicationStatusMessage self, std::string const & module, std::string const & username, Seiscomp::Client::ApplicationStatus status) -> ApplicationStatusMessage
        """
        _client.ApplicationStatusMessage_swiginit(self, _client.new_ApplicationStatusMessage(*args))

    def empty(self):
        r"""empty(ApplicationStatusMessage self) -> bool"""
        return _client.ApplicationStatusMessage_empty(self)

    def module(self):
        r"""module(ApplicationStatusMessage self) -> std::string const &"""
        return _client.ApplicationStatusMessage_module(self)

    def username(self):
        r"""username(ApplicationStatusMessage self) -> std::string const &"""
        return _client.ApplicationStatusMessage_username(self)

    def status(self):
        r"""status(ApplicationStatusMessage self) -> Seiscomp::Client::ApplicationStatus"""
        return _client.ApplicationStatusMessage_status(self)
    __swig_destroy__ = _client.delete_ApplicationStatusMessage

# Register ApplicationStatusMessage in _client:
_client.ApplicationStatusMessage_swigregister(ApplicationStatusMessage)

def ApplicationStatusMessage_ClassName():
    r"""ApplicationStatusMessage_ClassName() -> char const *"""
    return _client.ApplicationStatusMessage_ClassName()

def ApplicationStatusMessage_TypeInfo():
    r"""ApplicationStatusMessage_TypeInfo() -> RTTI"""
    return _client.ApplicationStatusMessage_TypeInfo()

def ApplicationStatusMessage_Cast(*args):
    r"""
    ApplicationStatusMessage_Cast(BaseObject o) -> ApplicationStatusMessage
    ApplicationStatusMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ApplicationStatusMessage
    """
    return _client.ApplicationStatusMessage_Cast(*args)

def ApplicationStatusMessage_ConstCast(*args):
    r"""
    ApplicationStatusMessage_ConstCast(BaseObject o) -> ApplicationStatusMessage
    ApplicationStatusMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ApplicationStatusMessage
    """
    return _client.ApplicationStatusMessage_ConstCast(*args)

class Notification(object):
    r"""Proxy of C++ Seiscomp::Client::Notification class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Object = _client.Notification_Object
    
    Disconnect = _client.Notification_Disconnect
    
    Reconnect = _client.Notification_Reconnect
    
    Close = _client.Notification_Close
    
    Timeout = _client.Notification_Timeout
    
    AcquisitionFinished = _client.Notification_AcquisitionFinished
    

    def __init__(self, *args):
        r"""
        __init__(Notification self) -> Notification
        __init__(Notification self, BaseObject o) -> Notification
        __init__(Notification self, int t) -> Notification
        __init__(Notification self, int t, BaseObject o) -> Notification
        """
        _client.Notification_swiginit(self, _client.new_Notification(*args))
    object = property(_client.Notification_object_get, _client.Notification_object_set, doc=r"""object : p.Seiscomp::Core::BaseObject""")
    type = property(_client.Notification_type_get, _client.Notification_type_set, doc=r"""type : int""")
    __swig_destroy__ = _client.delete_Notification

# Register Notification in _client:
_client.Notification_swigregister(Notification)

class Application(seiscomp.system.SystemApplication):
    r"""Proxy of C++ Seiscomp::Client::Application class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MESSAGING = _client.Application_MESSAGING
    
    DATABASE = _client.Application_DATABASE
    
    CST_QUANTITY = _client.Application_CST_QUANTITY
    

    def __init__(self, argc, argv):
        r"""__init__(Application self, int argc, char ** argv) -> Application"""

        argv = [ bytes(a.encode()) for a in argv ]


        if self.__class__ == Application:
            _self = None
        else:
            _self = self
        _client.Application_swiginit(self, _client.new_Application(_self, argc, argv))
    __swig_destroy__ = _client.delete_Application

    def agencyID(self):
        r"""agencyID(Application self) -> std::string const &"""
        return _client.Application_agencyID(self)

    def author(self):
        r"""author(Application self) -> std::string const &"""
        return _client.Application_author(self)

    def isAgencyIDAllowed(self, agencyID):
        r"""isAgencyIDAllowed(Application self, std::string const & agencyID) -> bool"""
        return _client.Application_isAgencyIDAllowed(self, agencyID)

    def isAgencyIDBlocked(self, agencyID):
        r"""isAgencyIDBlocked(Application self, std::string const & agencyID) -> bool"""
        return _client.Application_isAgencyIDBlocked(self, agencyID)

    def exit(self, returnCode):
        r"""exit(Application self, int returnCode)"""
        return _client.Application_exit(self, returnCode)

    def connection(self):
        r"""connection(Application self) -> Connection"""
        return _client.Application_connection(self)

    def databaseType(self):
        r"""databaseType(Application self) -> std::string const &"""
        return _client.Application_databaseType(self)

    def databaseParameters(self):
        r"""databaseParameters(Application self) -> std::string const &"""
        return _client.Application_databaseParameters(self)

    def database(self):
        r"""database(Application self) -> DatabaseInterface"""
        return _client.Application_database(self)

    def databaseURI(self):
        r"""databaseURI(Application self) -> std::string const &"""
        return _client.Application_databaseURI(self)

    def query(self):
        r"""query(Application self) -> DatabaseQuery"""
        return _client.Application_query(self)

    def recordStreamURL(self):
        r"""recordStreamURL(Application self) -> std::string const &"""
        return _client.Application_recordStreamURL(self)

    def cities(self):
        r"""cities(Application self) -> CityListD"""
        return _client.Application_cities(self)

    def nearestCity(self, lat, lon, maxDist, minPopulation):
        r"""nearestCity(Application self, double lat, double lon, double maxDist, double minPopulation) -> CityD"""
        return _client.Application_nearestCity(self, lat, lon, maxDist, minPopulation)

    def configModule(self):
        r"""configModule(Application self) -> ConfigModule"""
        return _client.Application_configModule(self)

    def isStationEnabled(self, networkCode, stationCode):
        r"""isStationEnabled(Application self, std::string const & networkCode, std::string const & stationCode) -> bool"""
        return _client.Application_isStationEnabled(self, networkCode, stationCode)

    def messagingURL(self):
        r"""messagingURL(Application self) -> std::string const &"""
        return _client.Application_messagingURL(self)

    def messagingCertificate(self):
        r"""messagingCertificate(Application self) -> std::string const &"""
        return _client.Application_messagingCertificate(self)

    def enableTimer(self, seconds):
        r"""enableTimer(Application self, unsigned int seconds)"""
        return _client.Application_enableTimer(self, seconds)

    def disableTimer(self):
        r"""disableTimer(Application self)"""
        return _client.Application_disableTimer(self)

    def sendNotification(self, arg2):
        r"""sendNotification(Application self, Notification arg2)"""
        return _client.Application_sendNotification(self, arg2)

    def waitEvent(self):
        r"""waitEvent(Application self) -> bool"""
        return _client.Application_waitEvent(self)

    def setPrimaryMessagingGroup(self, arg2):
        r"""setPrimaryMessagingGroup(Application self, std::string const & arg2)"""
        return _client.Application_setPrimaryMessagingGroup(self, arg2)

    def primaryMessagingGroup(self):
        r"""primaryMessagingGroup(Application self) -> std::string const &"""
        return _client.Application_primaryMessagingGroup(self)

    def setMessagingUsername(self, arg2):
        r"""setMessagingUsername(Application self, std::string const & arg2)"""
        return _client.Application_setMessagingUsername(self, arg2)

    def addMessagingSubscription(self, arg2):
        r"""addMessagingSubscription(Application self, std::string const & arg2)"""
        return _client.Application_addMessagingSubscription(self, arg2)

    def setDatabaseEnabled(self, enable, tryToFetch):
        r"""setDatabaseEnabled(Application self, bool enable, bool tryToFetch)"""
        return _client.Application_setDatabaseEnabled(self, enable, tryToFetch)

    def isDatabaseEnabled(self):
        r"""isDatabaseEnabled(Application self) -> bool"""
        return _client.Application_isDatabaseEnabled(self)

    def isInventoryDatabaseEnabled(self):
        r"""isInventoryDatabaseEnabled(Application self) -> bool"""
        return _client.Application_isInventoryDatabaseEnabled(self)

    def isConfigDatabaseEnabled(self):
        r"""isConfigDatabaseEnabled(Application self) -> bool"""
        return _client.Application_isConfigDatabaseEnabled(self)

    def setMessagingEnabled(self, enable):
        r"""setMessagingEnabled(Application self, bool enable)"""
        return _client.Application_setMessagingEnabled(self, enable)

    def isMessagingEnabled(self):
        r"""isMessagingEnabled(Application self) -> bool"""
        return _client.Application_isMessagingEnabled(self)

    def setMembershipMessagesEnabled(self, enable):
        r"""setMembershipMessagesEnabled(Application self, bool enable)"""
        return _client.Application_setMembershipMessagesEnabled(self, enable)

    def areMembershipMessagesEnabled(self):
        r"""areMembershipMessagesEnabled(Application self) -> bool"""
        return _client.Application_areMembershipMessagesEnabled(self)

    def setStartStopMessagesEnabled(self, enable):
        r"""setStartStopMessagesEnabled(Application self, bool enable)"""
        return _client.Application_setStartStopMessagesEnabled(self, enable)

    def areStartStopMessagesEnabled(self):
        r"""areStartStopMessagesEnabled(Application self) -> bool"""
        return _client.Application_areStartStopMessagesEnabled(self)

    def setAutoShutdownEnabled(self, enable):
        r"""setAutoShutdownEnabled(Application self, bool enable)"""
        return _client.Application_setAutoShutdownEnabled(self, enable)

    def isAutoShutdownEnabled(self):
        r"""isAutoShutdownEnabled(Application self) -> bool"""
        return _client.Application_isAutoShutdownEnabled(self)

    def setRecordStreamEnabled(self, enable):
        r"""setRecordStreamEnabled(Application self, bool enable)"""
        return _client.Application_setRecordStreamEnabled(self, enable)

    def isRecordStreamEnabled(self):
        r"""isRecordStreamEnabled(Application self) -> bool"""
        return _client.Application_isRecordStreamEnabled(self)

    def setLoadStationsEnabled(self, enable):
        r"""setLoadStationsEnabled(Application self, bool enable)"""
        return _client.Application_setLoadStationsEnabled(self, enable)

    def isLoadStationsEnabled(self):
        r"""isLoadStationsEnabled(Application self) -> bool"""
        return _client.Application_isLoadStationsEnabled(self)

    def setLoadInventoryEnabled(self, enable):
        r"""setLoadInventoryEnabled(Application self, bool enable)"""
        return _client.Application_setLoadInventoryEnabled(self, enable)

    def isLoadInventoryEnabled(self):
        r"""isLoadInventoryEnabled(Application self) -> bool"""
        return _client.Application_isLoadInventoryEnabled(self)

    def setLoadConfigModuleEnabled(self, enable):
        r"""setLoadConfigModuleEnabled(Application self, bool enable)"""
        return _client.Application_setLoadConfigModuleEnabled(self, enable)

    def isLoadConfigModuleEnabled(self):
        r"""isLoadConfigModuleEnabled(Application self) -> bool"""
        return _client.Application_isLoadConfigModuleEnabled(self)

    def setLoadCitiesEnabled(self, enable):
        r"""setLoadCitiesEnabled(Application self, bool enable)"""
        return _client.Application_setLoadCitiesEnabled(self, enable)

    def isLoadCitiesEnabled(self):
        r"""isLoadCitiesEnabled(Application self) -> bool"""
        return _client.Application_isLoadCitiesEnabled(self)

    def setLoadRegionsEnabled(self, enable):
        r"""setLoadRegionsEnabled(Application self, bool enable)"""
        return _client.Application_setLoadRegionsEnabled(self, enable)

    def isLoadRegionsEnabled(self):
        r"""isLoadRegionsEnabled(Application self) -> bool"""
        return _client.Application_isLoadRegionsEnabled(self)

    def setAutoApplyNotifierEnabled(self, enable):
        r"""setAutoApplyNotifierEnabled(Application self, bool enable)"""
        return _client.Application_setAutoApplyNotifierEnabled(self, enable)

    def isAutoApplyNotifierEnabled(self):
        r"""isAutoApplyNotifierEnabled(Application self) -> bool"""
        return _client.Application_isAutoApplyNotifierEnabled(self)

    def setInterpretNotifierEnabled(self, enable):
        r"""setInterpretNotifierEnabled(Application self, bool enable)"""
        return _client.Application_setInterpretNotifierEnabled(self, enable)

    def isInterpretNotifierEnabled(self):
        r"""isInterpretNotifierEnabled(Application self) -> bool"""
        return _client.Application_isInterpretNotifierEnabled(self)

    def hasCustomPublicIDPattern(self):
        r"""hasCustomPublicIDPattern(Application self) -> bool"""
        return _client.Application_hasCustomPublicIDPattern(self)

    def setConnectionRetries(self, arg2):
        r"""setConnectionRetries(Application self, unsigned int arg2)"""
        return _client.Application_setConnectionRetries(self, arg2)

    def setConfigModuleName(self, module):
        r"""setConfigModuleName(Application self, std::string const & module)"""
        return _client.Application_setConfigModuleName(self, module)

    def configModuleName(self):
        r"""configModuleName(Application self) -> std::string const &"""
        return _client.Application_configModuleName(self)

    def setShutdownMasterModule(self, module):
        r"""setShutdownMasterModule(Application self, std::string const & module)"""
        return _client.Application_setShutdownMasterModule(self, module)

    def setShutdownMasterUsername(self, username):
        r"""setShutdownMasterUsername(Application self, std::string const & username)"""
        return _client.Application_setShutdownMasterUsername(self, username)

    def addInputObjectLog(self, *args):
        r"""addInputObjectLog(Application self, std::string const & name, std::string const & channel="") -> RunningAverage"""
        return _client.Application_addInputObjectLog(self, *args)

    def addOutputObjectLog(self, *args):
        r"""addOutputObjectLog(Application self, std::string const & name, std::string const & channel="") -> RunningAverage"""
        return _client.Application_addOutputObjectLog(self, *args)

    def logObject(self, log, timestamp, count=1):
        r"""logObject(Application self, RunningAverage log, Time timestamp, size_t count=1)"""
        return _client.Application_logObject(self, log, timestamp, count)

    def reloadInventory(self):
        r"""reloadInventory(Application self) -> bool"""
        return _client.Application_reloadInventory(self)

    def reloadBindings(self):
        r"""reloadBindings(Application self) -> bool"""
        return _client.Application_reloadBindings(self)

    def injectMessage(self, msg, pkt=None):
        r"""injectMessage(Application self, Message msg, Packet pkt=None)"""
        return _client.Application_injectMessage(self, msg, pkt)

    def handleNotifier(self, notifier):
        r"""handleNotifier(Application self, Notifier notifier)"""
        return _client.Application_handleNotifier(self, notifier)

    @staticmethod
    def Instance():
        r"""Instance() -> Application"""
        return _client.Application_Instance()

    def validateParameters(self):
        r"""validateParameters(Application self) -> bool"""
        return _client.Application_validateParameters(self)

    def handlePreFork(self):
        r"""handlePreFork(Application self) -> bool"""
        return _client.Application_handlePreFork(self)

    def init(self):
        r"""init(Application self) -> bool"""
        return _client.Application_init(self)

    def run(self):
        r"""run(Application self) -> bool"""
        return _client.Application_run(self)

    def idle(self):
        r"""idle(Application self)"""
        return _client.Application_idle(self)

    def done(self):
        r"""done(Application self)"""
        return _client.Application_done(self)

    def initConfiguration(self):
        r"""initConfiguration(Application self) -> bool"""
        return _client.Application_initConfiguration(self)

    def initDatabase(self):
        r"""initDatabase(Application self) -> bool"""
        return _client.Application_initDatabase(self)

    def initSubscriptions(self):
        r"""initSubscriptions(Application self) -> bool"""
        return _client.Application_initSubscriptions(self)

    def handleEndAcquisition(self):
        r"""handleEndAcquisition(Application self)"""
        return _client.Application_handleEndAcquisition(self)

    def dispatch(self, arg0):
        r"""dispatch(Application self, BaseObject arg0) -> bool"""
        return _client.Application_dispatch(self, arg0)

    def dispatchNotification(self, type, arg0):
        r"""dispatchNotification(Application self, int type, BaseObject arg0) -> bool"""
        return _client.Application_dispatchNotification(self, type, arg0)

    def handleTimeout(self):
        r"""handleTimeout(Application self)"""
        return _client.Application_handleTimeout(self)

    def handleClose(self):
        r"""handleClose(Application self) -> bool"""
        return _client.Application_handleClose(self)

    def handleAutoShutdown(self):
        r"""handleAutoShutdown(Application self)"""
        return _client.Application_handleAutoShutdown(self)

    def handleDisconnect(self):
        r"""handleDisconnect(Application self)"""
        return _client.Application_handleDisconnect(self)

    def handleReconnect(self):
        r"""handleReconnect(Application self)"""
        return _client.Application_handleReconnect(self)

    def handleNetworkMessage(self, msg):
        r"""handleNetworkMessage(Application self, Packet msg)"""
        return _client.Application_handleNetworkMessage(self, msg)

    def handleMessage(self, msg):
        r"""handleMessage(Application self, Message msg)"""
        return _client.Application_handleMessage(self, msg)

    def addObject(self, parentID, arg0):
        r"""addObject(Application self, std::string const & parentID, Object arg0)"""
        return _client.Application_addObject(self, parentID, arg0)

    def removeObject(self, parentID, arg0):
        r"""removeObject(Application self, std::string const & parentID, Object arg0)"""
        return _client.Application_removeObject(self, parentID, arg0)

    def updateObject(self, parentID, arg0):
        r"""updateObject(Application self, std::string const & parentID, Object arg0)"""
        return _client.Application_updateObject(self, parentID, arg0)
    def __disown__(self):
        self.this.disown()
        _client.disown_Application(self)
        return weakref.proxy(self)

    def createBaseCommandLineDescription(self):
        r"""createBaseCommandLineDescription(Application self)"""
        return _client.Application_createBaseCommandLineDescription(self)

    def createCommandLineDescription(self):
        r"""createCommandLineDescription(Application self)"""
        return _client.Application_createCommandLineDescription(self)

    def handleCommandLineOptions(self):
        r"""handleCommandLineOptions(Application self) -> bool"""
        return _client.Application_handleCommandLineOptions(self)

    def forkProcess(self):
        r"""forkProcess(Application self) -> bool"""
        return _client.Application_forkProcess(self)

    def initPlugins(self):
        r"""initPlugins(Application self) -> bool"""
        return _client.Application_initPlugins(self)

    def printVersion(self):
        r"""printVersion(Application self)"""
        return _client.Application_printVersion(self)

    def printConfigVariables(self):
        r"""printConfigVariables(Application self)"""
        return _client.Application_printConfigVariables(self)

    def schemaValidationNames(self, modules, plugins):
        r"""schemaValidationNames(Application self, VectorStr modules, VectorStr plugins)"""
        return _client.Application_schemaValidationNames(self, modules, plugins)

    def validateSchemaParameters(self):
        r"""validateSchemaParameters(Application self) -> bool"""
        return _client.Application_validateSchemaParameters(self)

    def handleInitializationError(self, stage):
        r"""handleInitializationError(Application self, int stage) -> bool"""
        return _client.Application_handleInitializationError(self, stage)

    def showMessage(self, arg0):
        r"""showMessage(Application self, char const * arg0)"""
        return _client.Application_showMessage(self, arg0)

    def showWarning(self, arg0):
        r"""showWarning(Application self, char const * arg0)"""
        return _client.Application_showWarning(self, arg0)

# Register Application in _client:
_client.Application_swigregister(Application)

def Application_Instance():
    r"""Application_Instance() -> Application"""
    return _client.Application_Instance()

class StreamApplication(Application):
    r"""Proxy of C++ Seiscomp::Client::StreamApplication class."""

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

    def __init__(self, argc, argv):
        r"""__init__(StreamApplication self, int argc, char ** argv) -> StreamApplication"""

        argv = [ bytes(a.encode()) for a in argv ]


        if self.__class__ == StreamApplication:
            _self = None
        else:
            _self = self
        _client.StreamApplication_swiginit(self, _client.new_StreamApplication(_self, argc, argv))
    __swig_destroy__ = _client.delete_StreamApplication

    def openStream(self):
        r"""openStream(StreamApplication self) -> bool"""
        return _client.StreamApplication_openStream(self)

    def closeStream(self):
        r"""closeStream(StreamApplication self)"""
        return _client.StreamApplication_closeStream(self)

    def recordStream(self):
        r"""recordStream(StreamApplication self) -> RecordStream"""
        return _client.StreamApplication_recordStream(self)

    def addStation(self, networkCode, stationCode):
        r"""addStation(StreamApplication self, std::string const & networkCode, std::string const & stationCode) -> bool"""
        return _client.StreamApplication_addStation(self, networkCode, stationCode)

    def addStream(self, networkCode, stationCode, locationCode, channelCode):
        r"""addStream(StreamApplication self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode) -> bool"""
        return _client.StreamApplication_addStream(self, networkCode, stationCode, locationCode, channelCode)

    def setStartTime(self, arg2):
        r"""setStartTime(StreamApplication self, Time arg2)"""
        return _client.StreamApplication_setStartTime(self, arg2)

    def setEndTime(self, arg2):
        r"""setEndTime(StreamApplication self, Time arg2)"""
        return _client.StreamApplication_setEndTime(self, arg2)

    def setTimeWindow(self, arg2):
        r"""setTimeWindow(StreamApplication self, Seiscomp::Core::TimeWindow const & arg2) -> bool"""
        return _client.StreamApplication_setTimeWindow(self, arg2)

    def setAutoAcquisitionStart(self, arg2):
        r"""setAutoAcquisitionStart(StreamApplication self, bool arg2)"""
        return _client.StreamApplication_setAutoAcquisitionStart(self, arg2)

    def setAutoCloseOnAcquisitionFinished(self, arg2):
        r"""setAutoCloseOnAcquisitionFinished(StreamApplication self, bool arg2)"""
        return _client.StreamApplication_setAutoCloseOnAcquisitionFinished(self, arg2)

    def setRecordInputHint(self, hint):
        r"""setRecordInputHint(StreamApplication self, Seiscomp::Record::Hint hint)"""
        return _client.StreamApplication_setRecordInputHint(self, hint)

    def setRecordDatatype(self, datatype):
        r"""setRecordDatatype(StreamApplication self, Seiscomp::Array::DataType datatype)"""
        return _client.StreamApplication_setRecordDatatype(self, datatype)

    def recordDataType(self):
        r"""recordDataType(StreamApplication self) -> Seiscomp::Array::DataType"""
        return _client.StreamApplication_recordDataType(self)

    def startRecordThread(self):
        r"""startRecordThread(StreamApplication self)"""
        return _client.StreamApplication_startRecordThread(self)

    def waitForRecordThread(self):
        r"""waitForRecordThread(StreamApplication self)"""
        return _client.StreamApplication_waitForRecordThread(self)

    def isRecordThreadActive(self):
        r"""isRecordThreadActive(StreamApplication self) -> bool"""
        return _client.StreamApplication_isRecordThreadActive(self)

    def init(self):
        r"""init(StreamApplication self) -> bool"""
        return _client.StreamApplication_init(self)

    def run(self):
        r"""run(StreamApplication self) -> bool"""
        return _client.StreamApplication_run(self)

    def done(self):
        r"""done(StreamApplication self)"""
        return _client.StreamApplication_done(self)

    def dispatch(self, obj):
        r"""dispatch(StreamApplication self, BaseObject obj) -> bool"""
        return _client.StreamApplication_dispatch(self, obj)

    def handleRecord(self, rec):
        r"""handleRecord(StreamApplication self, Record rec)"""
        return _client.StreamApplication_handleRecord(self, rec)
    def __disown__(self):
        self.this.disown()
        _client.disown_StreamApplication(self)
        return weakref.proxy(self)

    def createBaseCommandLineDescription(self):
        r"""createBaseCommandLineDescription(StreamApplication self)"""
        return _client.StreamApplication_createBaseCommandLineDescription(self)

    def createCommandLineDescription(self):
        r"""createCommandLineDescription(StreamApplication self)"""
        return _client.StreamApplication_createCommandLineDescription(self)

    def handleCommandLineOptions(self):
        r"""handleCommandLineOptions(StreamApplication self) -> bool"""
        return _client.StreamApplication_handleCommandLineOptions(self)

    def handlePreFork(self):
        r"""handlePreFork(StreamApplication self) -> bool"""
        return _client.StreamApplication_handlePreFork(self)

    def validateParameters(self):
        r"""validateParameters(StreamApplication self) -> bool"""
        return _client.StreamApplication_validateParameters(self)

    def forkProcess(self):
        r"""forkProcess(StreamApplication self) -> bool"""
        return _client.StreamApplication_forkProcess(self)

    def initConfiguration(self):
        r"""initConfiguration(StreamApplication self) -> bool"""
        return _client.StreamApplication_initConfiguration(self)

    def initPlugins(self):
        r"""initPlugins(StreamApplication self) -> bool"""
        return _client.StreamApplication_initPlugins(self)

    def printVersion(self):
        r"""printVersion(StreamApplication self)"""
        return _client.StreamApplication_printVersion(self)

    def printConfigVariables(self):
        r"""printConfigVariables(StreamApplication self)"""
        return _client.StreamApplication_printConfigVariables(self)

    def schemaValidationNames(self, modules, plugins):
        r"""schemaValidationNames(StreamApplication self, VectorStr modules, VectorStr plugins)"""
        return _client.StreamApplication_schemaValidationNames(self, modules, plugins)

    def validateSchemaParameters(self):
        r"""validateSchemaParameters(StreamApplication self) -> bool"""
        return _client.StreamApplication_validateSchemaParameters(self)

    def handleInitializationError(self, stage):
        r"""handleInitializationError(StreamApplication self, int stage) -> bool"""
        return _client.StreamApplication_handleInitializationError(self, stage)

    def showMessage(self, arg0):
        r"""showMessage(StreamApplication self, char const * arg0)"""
        return _client.StreamApplication_showMessage(self, arg0)

    def showWarning(self, arg0):
        r"""showWarning(StreamApplication self, char const * arg0)"""
        return _client.StreamApplication_showWarning(self, arg0)

    def idle(self):
        r"""idle(StreamApplication self)"""
        return _client.StreamApplication_idle(self)

    def initDatabase(self):
        r"""initDatabase(StreamApplication self) -> bool"""
        return _client.StreamApplication_initDatabase(self)

    def initSubscriptions(self):
        r"""initSubscriptions(StreamApplication self) -> bool"""
        return _client.StreamApplication_initSubscriptions(self)

    def handleEndAcquisition(self):
        r"""handleEndAcquisition(StreamApplication self)"""
        return _client.StreamApplication_handleEndAcquisition(self)

    def dispatchNotification(self, type, arg0):
        r"""dispatchNotification(StreamApplication self, int type, BaseObject arg0) -> bool"""
        return _client.StreamApplication_dispatchNotification(self, type, arg0)

    def handleTimeout(self):
        r"""handleTimeout(StreamApplication self)"""
        return _client.StreamApplication_handleTimeout(self)

    def handleClose(self):
        r"""handleClose(StreamApplication self) -> bool"""
        return _client.StreamApplication_handleClose(self)

    def handleAutoShutdown(self):
        r"""handleAutoShutdown(StreamApplication self)"""
        return _client.StreamApplication_handleAutoShutdown(self)

    def handleDisconnect(self):
        r"""handleDisconnect(StreamApplication self)"""
        return _client.StreamApplication_handleDisconnect(self)

    def handleReconnect(self):
        r"""handleReconnect(StreamApplication self)"""
        return _client.StreamApplication_handleReconnect(self)

    def handleNetworkMessage(self, msg):
        r"""handleNetworkMessage(StreamApplication self, Packet msg)"""
        return _client.StreamApplication_handleNetworkMessage(self, msg)

    def handleMessage(self, msg):
        r"""handleMessage(StreamApplication self, Message msg)"""
        return _client.StreamApplication_handleMessage(self, msg)

    def addObject(self, parentID, arg0):
        r"""addObject(StreamApplication self, std::string const & parentID, Object arg0)"""
        return _client.StreamApplication_addObject(self, parentID, arg0)

    def removeObject(self, parentID, arg0):
        r"""removeObject(StreamApplication self, std::string const & parentID, Object arg0)"""
        return _client.StreamApplication_removeObject(self, parentID, arg0)

    def updateObject(self, parentID, arg0):
        r"""updateObject(StreamApplication self, std::string const & parentID, Object arg0)"""
        return _client.StreamApplication_updateObject(self, parentID, arg0)

# Register StreamApplication in _client:
_client.StreamApplication_swigregister(StreamApplication)

class StationLocation(object):
    r"""Proxy of C++ Seiscomp::Client::StationLocation class."""

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

    def __init__(self, *args):
        r"""
        __init__(StationLocation self) -> StationLocation
        __init__(StationLocation self, double lat, double lon, double elevation) -> StationLocation
        """
        _client.StationLocation_swiginit(self, _client.new_StationLocation(*args))
    latitude = property(_client.StationLocation_latitude_get, _client.StationLocation_latitude_set, doc=r"""latitude : double""")
    longitude = property(_client.StationLocation_longitude_get, _client.StationLocation_longitude_set, doc=r"""longitude : double""")
    elevation = property(_client.StationLocation_elevation_get, _client.StationLocation_elevation_set, doc=r"""elevation : double""")
    __swig_destroy__ = _client.delete_StationLocation

# Register StationLocation in _client:
_client.StationLocation_swigregister(StationLocation)

class Inventory(object):
    r"""Proxy of C++ Seiscomp::Client::Inventory class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def Instance():
        r"""Instance() -> Inventory"""
        return _client.Inventory_Instance()

    @staticmethod
    def Reset():
        r"""Reset()"""
        return _client.Inventory_Reset()

    def load(self, *args):
        r"""
        load(Inventory self, char const * filename)
        load(Inventory self, DatabaseReader arg2)
        """
        return _client.Inventory_load(self, *args)

    def setInventory(self, arg2):
        r"""setInventory(Inventory self, Inventory arg2)"""
        return _client.Inventory_setInventory(self, arg2)

    def filter(self, networkTypeFW, stationTypeFW):
        r"""filter(Inventory self, Seiscomp::Util::StringFirewall const * networkTypeFW, Seiscomp::Util::StringFirewall const * stationTypeFW) -> int"""
        return _client.Inventory_filter(self, networkTypeFW, stationTypeFW)

    def loadStations(self, arg2):
        r"""loadStations(Inventory self, DatabaseReader arg2)"""
        return _client.Inventory_loadStations(self, arg2)

    def stationLocation(self, networkCode, stationCode, arg4):
        r"""stationLocation(Inventory self, std::string const & networkCode, std::string const & stationCode, Time arg4) -> StationLocation"""
        return _client.Inventory_stationLocation(self, networkCode, stationCode, arg4)

    def getStation(self, *args):
        r"""
        getStation(Inventory self, std::string const & networkCode, std::string const & stationCode, Time arg4, Seiscomp::DataModel::InventoryError * error=None) -> Station
        getStation(Inventory self, Pick arg2) -> Station
        """
        return _client.Inventory_getStation(self, *args)

    def getSensorLocation(self, *args):
        r"""
        getSensorLocation(Inventory self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, Time arg5, Seiscomp::DataModel::InventoryError * error=None) -> SensorLocation
        getSensorLocation(Inventory self, Pick arg2) -> SensorLocation
        """
        return _client.Inventory_getSensorLocation(self, *args)

    def getStream(self, *args):
        r"""
        getStream(Inventory self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, Time arg6, Seiscomp::DataModel::InventoryError * error=None) -> Stream
        getStream(Inventory self, Pick arg2) -> Stream
        """
        return _client.Inventory_getStream(self, *args)

    def getThreeComponents(self, *args):
        r"""
        getThreeComponents(Inventory self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, Time arg6) -> ThreeComponents
        getThreeComponents(Inventory self, Pick arg2) -> ThreeComponents
        """
        return _client.Inventory_getThreeComponents(self, *args)

    def getGain(self, networkCode, stationCode, locationCode, channelCode, arg6):
        r"""getGain(Inventory self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, Time arg6) -> double"""
        return _client.Inventory_getGain(self, networkCode, stationCode, locationCode, channelCode, arg6)

    def getAllStations(self, arg2, arg3):
        r"""getAllStations(Inventory self, Seiscomp::Client::StationList & arg2, Time arg3) -> int"""
        return _client.Inventory_getAllStations(self, arg2, arg3)

    def inventory(self):
        r"""inventory(Inventory self) -> Inventory"""
        return _client.Inventory_inventory(self)
    __swig_destroy__ = _client.delete_Inventory

# Register Inventory in _client:
_client.Inventory_swigregister(Inventory)

def Inventory_Instance():
    r"""Inventory_Instance() -> Inventory"""
    return _client.Inventory_Instance()

def Inventory_Reset():
    r"""Inventory_Reset()"""
    return _client.Inventory_Reset()

class ConfigDB(object):
    r"""Proxy of C++ Seiscomp::Client::ConfigDB class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def Instance():
        r"""Instance() -> ConfigDB"""
        return _client.ConfigDB_Instance()

    @staticmethod
    def Reset():
        r"""Reset()"""
        return _client.ConfigDB_Reset()

    def load(self, *args):
        r"""
        load(ConfigDB self, DatabaseReader reader, Seiscomp::Core::Optional< std::string >::Impl const & moduleName=Unset, Seiscomp::Core::Optional< std::string >::Impl const & networkCode=Unset, Seiscomp::Core::Optional< std::string >::Impl const & stationCode=Unset, Seiscomp::Core::Optional< std::string >::Impl const & setupName=Unset, std::set< std::string,std::less< std::string >,std::allocator< std::string > > const & parameterNames=std::set< std::string >())
        load(ConfigDB self, char const * xml)
        """
        return _client.ConfigDB_load(self, *args)

    def config(self):
        r"""config(ConfigDB self) -> Config"""
        return _client.ConfigDB_config(self)
    __swig_destroy__ = _client.delete_ConfigDB

# Register ConfigDB in _client:
_client.ConfigDB_swigregister(ConfigDB)

def ConfigDB_Instance():
    r"""ConfigDB_Instance() -> ConfigDB"""
    return _client.ConfigDB_Instance()

def ConfigDB_Reset():
    r"""ConfigDB_Reset()"""
    return _client.ConfigDB_Reset()