# 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 _datamodel
else:
    import _datamodel

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import seiscomp.io
import seiscomp.math
import seiscomp.core
import seiscomp.geo
class NotifierMessageBase(seiscomp.core.Message):
    r"""Proxy of C++ Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier > class."""

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

    def serialize(self, ar):
        r"""serialize(NotifierMessageBase self, GenericArchive ar)"""
        return _datamodel.NotifierMessageBase_serialize(self, ar)

    def __init__(self):
        r"""__init__(NotifierMessageBase self) -> NotifierMessageBase"""
        _datamodel.NotifierMessageBase_swiginit(self, _datamodel.new_NotifierMessageBase())
    __swig_destroy__ = _datamodel.delete_NotifierMessageBase

    def attach(self, *args):
        r"""
        attach(NotifierMessageBase self, Notifier attachment) -> bool
        attach(NotifierMessageBase self, Seiscomp::Core::SmartPointer< Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::AttachementType >::Impl & attachment) -> bool
        """
        return _datamodel.NotifierMessageBase_attach(self, *args)

    def detach(self, *args):
        r"""
        detach(NotifierMessageBase self, Notifier attachment) -> bool
        detach(NotifierMessageBase self, Seiscomp::Core::SmartPointer< Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::AttachementType >::Impl & attachment) -> bool
        detach(NotifierMessageBase self, Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::iterator it) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::iterator
        """
        return _datamodel.NotifierMessageBase_detach(self, *args)

    def clear(self):
        r"""clear(NotifierMessageBase self)"""
        return _datamodel.NotifierMessageBase_clear(self)

    def begin(self, *args):
        r"""
        begin(NotifierMessageBase self) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::iterator
        begin(NotifierMessageBase self) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::const_iterator
        """
        return _datamodel.NotifierMessageBase_begin(self, *args)

    def end(self, *args):
        r"""
        end(NotifierMessageBase self) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::iterator
        end(NotifierMessageBase self) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::const_iterator
        """
        return _datamodel.NotifierMessageBase_end(self, *args)

    def empty(self):
        r"""empty(NotifierMessageBase self) -> bool"""
        return _datamodel.NotifierMessageBase_empty(self)

    def size(self):
        r"""size(NotifierMessageBase self) -> int"""
        return _datamodel.NotifierMessageBase_size(self)

# Register NotifierMessageBase in _datamodel:
_datamodel.NotifierMessageBase_swigregister(NotifierMessageBase)

class Observer(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::Observer 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 _datamodel.Observer_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Observer_TypeInfo()

    def className(self):
        r"""className(Observer self) -> char const *"""
        return _datamodel.Observer_className(self)

    def typeInfo(self):
        r"""typeInfo(Observer self) -> RTTI"""
        return _datamodel.Observer_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Observer
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Observer
        """
        return _datamodel.Observer_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Observer
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Observer
        """
        return _datamodel.Observer_ConstCast(*args)
    __swig_destroy__ = _datamodel.delete_Observer

    def onObjectAdded(self, parent, newChild):
        r"""onObjectAdded(Observer self, Object parent, Object newChild)"""
        return _datamodel.Observer_onObjectAdded(self, parent, newChild)

    def onObjectRemoved(self, parent, oldChild):
        r"""onObjectRemoved(Observer self, Object parent, Object oldChild)"""
        return _datamodel.Observer_onObjectRemoved(self, parent, oldChild)

    def onObjectModified(self, object):
        r"""onObjectModified(Observer self, Object object)"""
        return _datamodel.Observer_onObjectModified(self, object)

    def onObjectDestroyed(self, object):
        r"""onObjectDestroyed(Observer self, Object object)"""
        return _datamodel.Observer_onObjectDestroyed(self, object)

# Register Observer in _datamodel:
_datamodel.Observer_swigregister(Observer)

def Observer_ClassName():
    r"""Observer_ClassName() -> char const *"""
    return _datamodel.Observer_ClassName()

def Observer_TypeInfo():
    r"""Observer_TypeInfo() -> RTTI"""
    return _datamodel.Observer_TypeInfo()

def Observer_Cast(*args):
    r"""
    Observer_Cast(BaseObject o) -> Observer
    Observer_Cast(Seiscomp::Core::BaseObjectPtr o) -> Observer
    """
    return _datamodel.Observer_Cast(*args)

def Observer_ConstCast(*args):
    r"""
    Observer_ConstCast(BaseObject o) -> Observer
    Observer_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Observer
    """
    return _datamodel.Observer_ConstCast(*args)

class Visitor(object):
    r"""Proxy of C++ Seiscomp::DataModel::Visitor 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
    TM_TOPDOWN = _datamodel.Visitor_TM_TOPDOWN
    
    TM_BOTTOMUP = _datamodel.Visitor_TM_BOTTOMUP
    
    TM_QUANTITY = _datamodel.Visitor_TM_QUANTITY
    
    __swig_destroy__ = _datamodel.delete_Visitor

    def traversal(self):
        r"""traversal(Visitor self) -> Seiscomp::DataModel::Visitor::TraversalMode"""
        return _datamodel.Visitor_traversal(self)

    def visit(self, *args):
        r"""
        visit(Visitor self, PublicObject arg2) -> bool
        visit(Visitor self, Object arg2)
        """
        return _datamodel.Visitor_visit(self, *args)

    def finished(self):
        r"""finished(Visitor self)"""
        return _datamodel.Visitor_finished(self)

# Register Visitor in _datamodel:
_datamodel.Visitor_swigregister(Visitor)

OP_UNDEFINED = _datamodel.OP_UNDEFINED

OP_ADD = _datamodel.OP_ADD

OP_REMOVE = _datamodel.OP_REMOVE

OP_UPDATE = _datamodel.OP_UPDATE

EOperationQuantity = _datamodel.EOperationQuantity

class EOperationNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EOperationNames 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__(EOperationNames self) -> EOperationNames"""
        _datamodel.EOperationNames_swiginit(self, _datamodel.new_EOperationNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EOperationNames_name(i)
    __swig_destroy__ = _datamodel.delete_EOperationNames

# Register EOperationNames in _datamodel:
_datamodel.EOperationNames_swigregister(EOperationNames)

def EOperationNames_name(i):
    r"""EOperationNames_name(int i) -> char const *"""
    return _datamodel.EOperationNames_name(i)

class Object(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::Object 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

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

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Object_TypeInfo()

    def className(self):
        r"""className(Object self) -> char const *"""
        return _datamodel.Object_className(self)

    def typeInfo(self):
        r"""typeInfo(Object self) -> RTTI"""
        return _datamodel.Object_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Object
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Object
        """
        return _datamodel.Object_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Object
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Object
        """
        return _datamodel.Object_ConstCast(*args)
    __swig_destroy__ = _datamodel.delete_Object

    def parent(self):
        r"""parent(Object self) -> PublicObject"""
        return _datamodel.Object_parent(self)

    def setParent(self, parent):
        r"""setParent(Object self, PublicObject parent) -> bool"""
        return _datamodel.Object_setParent(self, parent)

    @staticmethod
    def RegisterObserver(arg1):
        r"""RegisterObserver(Observer arg1) -> bool"""
        return _datamodel.Object_RegisterObserver(arg1)

    @staticmethod
    def UnregisterObserver(arg1):
        r"""UnregisterObserver(Observer arg1) -> bool"""
        return _datamodel.Object_UnregisterObserver(arg1)

    def update(self):
        r"""update(Object self)"""
        return _datamodel.Object_update(self)

    def setLastModifiedInArchive(self, t):
        r"""setLastModifiedInArchive(Object self, Time t)"""
        return _datamodel.Object_setLastModifiedInArchive(self, t)

    def lastModifiedInArchive(self):
        r"""lastModifiedInArchive(Object self) -> Time"""
        return _datamodel.Object_lastModifiedInArchive(self)

    def assign(self, other):
        r"""assign(Object self, Object other) -> bool"""
        return _datamodel.Object_assign(self, other)

    def clone(self):
        r"""clone(Object self) -> Object"""
        return _datamodel.Object_clone(self)

    def attachTo(self, parent):
        r"""attachTo(Object self, PublicObject parent) -> bool"""
        return _datamodel.Object_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Object self, PublicObject parent) -> bool"""
        return _datamodel.Object_detachFrom(self, parent)

    def detach(self):
        r"""detach(Object self) -> bool"""
        return _datamodel.Object_detach(self)

    def accept(self, arg2):
        r"""accept(Object self, Visitor arg2)"""
        return _datamodel.Object_accept(self, arg2)

# Register Object in _datamodel:
_datamodel.Object_swigregister(Object)

def Object_ClassName():
    r"""Object_ClassName() -> char const *"""
    return _datamodel.Object_ClassName()

def Object_TypeInfo():
    r"""Object_TypeInfo() -> RTTI"""
    return _datamodel.Object_TypeInfo()

def Object_Cast(*args):
    r"""
    Object_Cast(BaseObject o) -> Object
    Object_Cast(Seiscomp::Core::BaseObjectPtr o) -> Object
    """
    return _datamodel.Object_Cast(*args)

def Object_ConstCast(*args):
    r"""
    Object_ConstCast(BaseObject o) -> Object
    Object_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Object
    """
    return _datamodel.Object_ConstCast(*args)

def Object_RegisterObserver(arg1):
    r"""Object_RegisterObserver(Observer arg1) -> bool"""
    return _datamodel.Object_RegisterObserver(arg1)

def Object_UnregisterObserver(arg1):
    r"""Object_UnregisterObserver(Observer arg1) -> bool"""
    return _datamodel.Object_UnregisterObserver(arg1)

class PublicObject(Object):
    r"""Proxy of C++ Seiscomp::DataModel::PublicObject 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

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

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.PublicObject_TypeInfo()

    def className(self):
        r"""className(PublicObject self) -> char const *"""
        return _datamodel.PublicObject_className(self)

    def typeInfo(self):
        r"""typeInfo(PublicObject self) -> RTTI"""
        return _datamodel.PublicObject_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> PublicObject
        Cast(Seiscomp::Core::BaseObjectPtr o) -> PublicObject
        """
        return _datamodel.PublicObject_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> PublicObject
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PublicObject
        """
        return _datamodel.PublicObject_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(PublicObject self, GenericArchive ar)"""
        return _datamodel.PublicObject_serialize(self, ar)
    __swig_destroy__ = _datamodel.delete_PublicObject

    def __eq__(self, arg2):
        r"""__eq__(PublicObject self, PublicObject arg2) -> bool"""
        return _datamodel.PublicObject___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(PublicObject self, PublicObject arg2) -> bool"""
        return _datamodel.PublicObject___ne__(self, arg2)

    def publicID(self):
        r"""publicID(PublicObject self) -> std::string const &"""
        return _datamodel.PublicObject_publicID(self)

    def setPublicID(self, arg2):
        r"""setPublicID(PublicObject self, std::string const & arg2) -> bool"""
        return _datamodel.PublicObject_setPublicID(self, arg2)

    def registered(self):
        r"""registered(PublicObject self) -> bool"""
        return _datamodel.PublicObject_registered(self)

    def registerMe(self):
        r"""registerMe(PublicObject self) -> bool"""
        return _datamodel.PublicObject_registerMe(self)

    def deregisterMe(self):
        r"""deregisterMe(PublicObject self) -> bool"""
        return _datamodel.PublicObject_deregisterMe(self)

    def validId(self):
        r"""validId(PublicObject self) -> bool"""
        return _datamodel.PublicObject_validId(self)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> PublicObject"""
        return _datamodel.PublicObject_Find(publicID)

    @staticmethod
    def ObjectCount():
        r"""ObjectCount() -> size_t"""
        return _datamodel.PublicObject_ObjectCount()

    @staticmethod
    def Begin():
        r"""Begin() -> Seiscomp::DataModel::PublicObject::Iterator"""
        return _datamodel.PublicObject_Begin()

    @staticmethod
    def End():
        r"""End() -> Seiscomp::DataModel::PublicObject::Iterator"""
        return _datamodel.PublicObject_End()

    @staticmethod
    def SetIdGeneration(arg1):
        r"""SetIdGeneration(bool arg1)"""
        return _datamodel.PublicObject_SetIdGeneration(arg1)

    @staticmethod
    def SetIdPattern(pattern):
        r"""SetIdPattern(std::string const & pattern)"""
        return _datamodel.PublicObject_SetIdPattern(pattern)

    @staticmethod
    def GenerateId(*args):
        r"""
        GenerateId(PublicObject object) -> PublicObject
        GenerateId(PublicObject object, std::string const & pattern) -> PublicObject
        """
        return _datamodel.PublicObject_GenerateId(*args)

    @staticmethod
    def SetRegistrationEnabled(enable):
        r"""SetRegistrationEnabled(bool enable)"""
        return _datamodel.PublicObject_SetRegistrationEnabled(enable)

    @staticmethod
    def IsRegistrationEnabled():
        r"""IsRegistrationEnabled() -> bool"""
        return _datamodel.PublicObject_IsRegistrationEnabled()

    def updateChild(self, arg2):
        r"""updateChild(PublicObject self, Object arg2) -> bool"""
        return _datamodel.PublicObject_updateChild(self, arg2)

    def accept(self, arg2):
        r"""accept(PublicObject self, Visitor arg2)"""
        return _datamodel.PublicObject_accept(self, arg2)

# Register PublicObject in _datamodel:
_datamodel.PublicObject_swigregister(PublicObject)

def PublicObject_ClassName():
    r"""PublicObject_ClassName() -> char const *"""
    return _datamodel.PublicObject_ClassName()

def PublicObject_TypeInfo():
    r"""PublicObject_TypeInfo() -> RTTI"""
    return _datamodel.PublicObject_TypeInfo()

def PublicObject_Cast(*args):
    r"""
    PublicObject_Cast(BaseObject o) -> PublicObject
    PublicObject_Cast(Seiscomp::Core::BaseObjectPtr o) -> PublicObject
    """
    return _datamodel.PublicObject_Cast(*args)

def PublicObject_ConstCast(*args):
    r"""
    PublicObject_ConstCast(BaseObject o) -> PublicObject
    PublicObject_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PublicObject
    """
    return _datamodel.PublicObject_ConstCast(*args)

def PublicObject_Find(publicID):
    r"""PublicObject_Find(std::string const & publicID) -> PublicObject"""
    return _datamodel.PublicObject_Find(publicID)

def PublicObject_ObjectCount():
    r"""PublicObject_ObjectCount() -> size_t"""
    return _datamodel.PublicObject_ObjectCount()

def PublicObject_Begin():
    r"""PublicObject_Begin() -> Seiscomp::DataModel::PublicObject::Iterator"""
    return _datamodel.PublicObject_Begin()

def PublicObject_End():
    r"""PublicObject_End() -> Seiscomp::DataModel::PublicObject::Iterator"""
    return _datamodel.PublicObject_End()

def PublicObject_SetIdGeneration(arg1):
    r"""PublicObject_SetIdGeneration(bool arg1)"""
    return _datamodel.PublicObject_SetIdGeneration(arg1)

def PublicObject_SetIdPattern(pattern):
    r"""PublicObject_SetIdPattern(std::string const & pattern)"""
    return _datamodel.PublicObject_SetIdPattern(pattern)

def PublicObject_GenerateId(*args):
    r"""
    PublicObject_GenerateId(PublicObject object) -> PublicObject
    PublicObject_GenerateId(PublicObject object, std::string const & pattern) -> PublicObject
    """
    return _datamodel.PublicObject_GenerateId(*args)

def PublicObject_SetRegistrationEnabled(enable):
    r"""PublicObject_SetRegistrationEnabled(bool enable)"""
    return _datamodel.PublicObject_SetRegistrationEnabled(enable)

def PublicObject_IsRegistrationEnabled():
    r"""PublicObject_IsRegistrationEnabled() -> bool"""
    return _datamodel.PublicObject_IsRegistrationEnabled()

class DatabaseIterator(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::DatabaseIterator 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__(DatabaseIterator self) -> DatabaseIterator
        __init__(DatabaseIterator self, DatabaseIterator iter) -> DatabaseIterator
        """
        _datamodel.DatabaseIterator_swiginit(self, _datamodel.new_DatabaseIterator(*args))
    __swig_destroy__ = _datamodel.delete_DatabaseIterator

    def get(self):
        r"""get(DatabaseIterator self) -> Object"""
        return _datamodel.DatabaseIterator_get(self)

    def fieldCount(self):
        r"""fieldCount(DatabaseIterator self) -> size_t"""
        return _datamodel.DatabaseIterator_fieldCount(self)

    def field(self, index):
        r"""field(DatabaseIterator self, size_t index) -> char const *"""
        return _datamodel.DatabaseIterator_field(self, index)

    def __ref__(self):
        r"""__ref__(DatabaseIterator self) -> Object"""
        return _datamodel.DatabaseIterator___ref__(self)

    def valid(self):
        r"""valid(DatabaseIterator self) -> bool"""
        return _datamodel.DatabaseIterator_valid(self)

    def close(self):
        r"""close(DatabaseIterator self)"""
        return _datamodel.DatabaseIterator_close(self)

    def count(self):
        r"""count(DatabaseIterator self) -> size_t"""
        return _datamodel.DatabaseIterator_count(self)

    def lastModified(self):
        r"""lastModified(DatabaseIterator self) -> Time"""
        return _datamodel.DatabaseIterator_lastModified(self)

    def oid(self):
        r"""oid(DatabaseIterator self) -> Seiscomp::DataModel::DatabaseIterator::OID"""
        return _datamodel.DatabaseIterator_oid(self)

    def parentOid(self):
        r"""parentOid(DatabaseIterator self) -> Seiscomp::DataModel::DatabaseIterator::OID"""
        return _datamodel.DatabaseIterator_parentOid(self)

    def cached(self):
        r"""cached(DatabaseIterator self) -> bool"""
        return _datamodel.DatabaseIterator_cached(self)

    def step(self):
        r"""step(DatabaseIterator self)"""
        return _datamodel.DatabaseIterator_step(self)

    def __iter__(self):
        return self

    def __next__(self):
        o = self.get()
        if not o:
            raise StopIteration

        self.step()
        return o

    # for Python 2 compatibility
    def next(self):
        return self.__next__()


# Register DatabaseIterator in _datamodel:
_datamodel.DatabaseIterator_swigregister(DatabaseIterator)

class DatabaseObjectWriter(object):
    r"""Proxy of C++ Seiscomp::DataModel::DatabaseObjectWriter 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, archive, addToDatabase=True, batchSize=1):
        r"""__init__(DatabaseObjectWriter self, DatabaseArchive archive, bool addToDatabase=True, int batchSize=1) -> DatabaseObjectWriter"""
        _datamodel.DatabaseObjectWriter_swiginit(self, _datamodel.new_DatabaseObjectWriter(archive, addToDatabase, batchSize))

    def __call__(self, *args):
        r"""
        __call__(DatabaseObjectWriter self, Object object) -> bool
        __call__(DatabaseObjectWriter self, Object object, std::string const & parentID) -> bool
        """
        return _datamodel.DatabaseObjectWriter___call__(self, *args)

    def count(self):
        r"""count(DatabaseObjectWriter self) -> int"""
        return _datamodel.DatabaseObjectWriter_count(self)

    def errors(self):
        r"""errors(DatabaseObjectWriter self) -> int"""
        return _datamodel.DatabaseObjectWriter_errors(self)
    __swig_destroy__ = _datamodel.delete_DatabaseObjectWriter

# Register DatabaseObjectWriter in _datamodel:
_datamodel.DatabaseObjectWriter_swigregister(DatabaseObjectWriter)

class DatabaseArchive(Observer):
    r"""Proxy of C++ Seiscomp::DataModel::DatabaseArchive 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, dbDriver):
        r"""__init__(DatabaseArchive self, DatabaseInterface dbDriver) -> DatabaseArchive"""
        _datamodel.DatabaseArchive_swiginit(self, _datamodel.new_DatabaseArchive(dbDriver))
    __swig_destroy__ = _datamodel.delete_DatabaseArchive

    def open(self, dataSource):
        r"""open(DatabaseArchive self, char const * dataSource) -> bool"""
        return _datamodel.DatabaseArchive_open(self, dataSource)

    def close(self):
        r"""close(DatabaseArchive self)"""
        return _datamodel.DatabaseArchive_close(self)

    def driver(self):
        r"""driver(DatabaseArchive self) -> DatabaseInterface"""
        return _datamodel.DatabaseArchive_driver(self)

    def setDriver(self, arg2):
        r"""setDriver(DatabaseArchive self, DatabaseInterface arg2)"""
        return _datamodel.DatabaseArchive_setDriver(self, arg2)

    def hasError(self):
        r"""hasError(DatabaseArchive self) -> bool"""
        return _datamodel.DatabaseArchive_hasError(self)

    def errorMsg(self):
        r"""errorMsg(DatabaseArchive self) -> std::string const"""
        return _datamodel.DatabaseArchive_errorMsg(self)

    def benchmarkQueries(self, count):
        r"""benchmarkQueries(DatabaseArchive self, int count)"""
        return _datamodel.DatabaseArchive_benchmarkQueries(self, count)

    def getObject(self, classType, publicID):
        r"""getObject(DatabaseArchive self, RTTI classType, std::string const & publicID) -> PublicObject"""
        return _datamodel.DatabaseArchive_getObject(self, classType, publicID)

    def getObjects(self, *args):
        r"""
        getObjects(DatabaseArchive self, std::string const & parentID, RTTI classType, bool ignorePublicObject=False) -> DatabaseIterator
        getObjects(DatabaseArchive self, PublicObject parent, RTTI classType, bool ignorePublicObject=False) -> DatabaseIterator
        """
        return _datamodel.DatabaseArchive_getObjects(self, *args)

    def getObjectCount(self, *args):
        r"""
        getObjectCount(DatabaseArchive self, std::string const & parentID, RTTI classType) -> size_t
        getObjectCount(DatabaseArchive self, PublicObject parent, RTTI classType) -> size_t
        """
        return _datamodel.DatabaseArchive_getObjectCount(self, *args)

    def getCachedId(self, arg2):
        r"""getCachedId(DatabaseArchive self, Object arg2) -> Seiscomp::DataModel::DatabaseArchive::OID"""
        return _datamodel.DatabaseArchive_getCachedId(self, arg2)

    def parentPublicID(self, object):
        r"""parentPublicID(DatabaseArchive self, PublicObject object) -> std::string"""
        return _datamodel.DatabaseArchive_parentPublicID(self, object)

    def write(self, *args):
        r"""write(DatabaseArchive self, Object object, std::string const & parentID="") -> bool"""
        return _datamodel.DatabaseArchive_write(self, *args)

    def update(self, *args):
        r"""update(DatabaseArchive self, Object object, std::string const & parentID="") -> bool"""
        return _datamodel.DatabaseArchive_update(self, *args)

    def remove(self, *args):
        r"""remove(DatabaseArchive self, Object object, std::string const & parentID="") -> bool"""
        return _datamodel.DatabaseArchive_remove(self, *args)

    def addTree(self, *args):
        r"""addTree(DatabaseArchive self, Object object, std::string const & parentID="", int * objectsHandled=None) -> bool"""
        return _datamodel.DatabaseArchive_addTree(self, *args)

    def removeTree(self, *args):
        r"""removeTree(DatabaseArchive self, Object object, std::string const & parentID="", int * objectsHandled=None) -> bool"""
        return _datamodel.DatabaseArchive_removeTree(self, *args)

    def getObjectIterator(self, *args):
        r"""
        getObjectIterator(DatabaseArchive self, std::string const & query, RTTI classType) -> DatabaseIterator
        getObjectIterator(DatabaseArchive self, std::string const & query, RTTI classType) -> DatabaseIterator
        """
        return _datamodel.DatabaseArchive_getObjectIterator(self, *args)

    def toString(self, *args):
        r"""
        toString(DatabaseArchive self, std::string const & value) -> std::string
        toString(DatabaseArchive self, char const * value) -> std::string
        toString(DatabaseArchive self, Time value) -> std::string
        """
        return _datamodel.DatabaseArchive_toString(self, *args)

# Register DatabaseArchive in _datamodel:
_datamodel.DatabaseArchive_swigregister(DatabaseArchive)

class CachePopCallback(object):
    r"""Proxy of C++ Seiscomp::DataModel::CachePopCallback class."""

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

    def handle(self, obj):
        r"""handle(CachePopCallback self, PublicObject obj)"""
        return _datamodel.CachePopCallback_handle(self, obj)
    __swig_destroy__ = _datamodel.delete_CachePopCallback

    def __init__(self):
        r"""__init__(CachePopCallback self) -> CachePopCallback"""
        if self.__class__ == CachePopCallback:
            _self = None
        else:
            _self = self
        _datamodel.CachePopCallback_swiginit(self, _datamodel.new_CachePopCallback(_self, ))
    def __disown__(self):
        self.this.disown()
        _datamodel.disown_CachePopCallback(self)
        return weakref.proxy(self)

# Register CachePopCallback in _datamodel:
_datamodel.CachePopCallback_swigregister(CachePopCallback)

class PublicObjectCache(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::PublicObjectCache 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
    __swig_destroy__ = _datamodel.delete_PublicObjectCache

    def setDatabaseArchive(self, arg2):
        r"""setDatabaseArchive(PublicObjectCache self, DatabaseArchive arg2)"""
        return _datamodel.PublicObjectCache_setDatabaseArchive(self, arg2)

    def setPopCallback(self, *args):
        r"""
        setPopCallback(PublicObjectCache self, Seiscomp::DataModel::PublicObjectCache::PopCallback const & arg2)
        setPopCallback(PublicObjectCache self, CachePopCallback arg2)
        """
        return _datamodel.PublicObjectCache_setPopCallback(self, *args)

    def removePopCallback(self):
        r"""removePopCallback(PublicObjectCache self)"""
        return _datamodel.PublicObjectCache_removePopCallback(self)

    def feed(self, po):
        r"""feed(PublicObjectCache self, PublicObject po) -> bool"""
        return _datamodel.PublicObjectCache_feed(self, po)

    def remove(self, po):
        r"""remove(PublicObjectCache self, PublicObject po) -> bool"""
        return _datamodel.PublicObjectCache_remove(self, po)

    def clear(self):
        r"""clear(PublicObjectCache self)"""
        return _datamodel.PublicObjectCache_clear(self)

    def typeInfo(self, publicID):
        r"""typeInfo(PublicObjectCache self, std::string const & publicID) -> RTTI"""
        return _datamodel.PublicObjectCache_typeInfo(self, publicID)

    def find(self, classType, publicID):
        r"""find(PublicObjectCache self, RTTI classType, std::string const & publicID) -> PublicObject"""
        return _datamodel.PublicObjectCache_find(self, classType, publicID)

    def cached(self):
        r"""cached(PublicObjectCache self) -> bool"""
        return _datamodel.PublicObjectCache_cached(self)

    def timeWindow(self):
        r"""timeWindow(PublicObjectCache self) -> Seiscomp::Core::TimeWindow"""
        return _datamodel.PublicObjectCache_timeWindow(self)

    def oldest(self):
        r"""oldest(PublicObjectCache self) -> Time"""
        return _datamodel.PublicObjectCache_oldest(self)

    def empty(self):
        r"""empty(PublicObjectCache self) -> bool"""
        return _datamodel.PublicObjectCache_empty(self)

    def size(self):
        r"""size(PublicObjectCache self) -> size_t"""
        return _datamodel.PublicObjectCache_size(self)

    def contains(self, *args):
        r"""
        contains(PublicObjectCache self, PublicObject object) -> bool
        contains(PublicObjectCache self, std::string const & publicID) -> bool
        """
        return _datamodel.PublicObjectCache_contains(self, *args)

    def get(self, klass, publicID):
        o = self.find(klass.TypeInfo(), publicID)
        return klass.Cast(o)

    def __iter__(self):
        return PublicObjectCacheIterator(self)


# Register PublicObjectCache in _datamodel:
_datamodel.PublicObjectCache_swigregister(PublicObjectCache)

class PublicObjectRingBuffer(PublicObjectCache):
    r"""Proxy of C++ Seiscomp::DataModel::PublicObjectRingBuffer 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__(PublicObjectRingBuffer self) -> PublicObjectRingBuffer
        __init__(PublicObjectRingBuffer self, DatabaseArchive ar, size_t bufferSize) -> PublicObjectRingBuffer
        """
        _datamodel.PublicObjectRingBuffer_swiginit(self, _datamodel.new_PublicObjectRingBuffer(*args))

    def setBufferSize(self, bufferSize):
        r"""setBufferSize(PublicObjectRingBuffer self, size_t bufferSize) -> bool"""
        return _datamodel.PublicObjectRingBuffer_setBufferSize(self, bufferSize)

    def feed(self, po):
        r"""feed(PublicObjectRingBuffer self, PublicObject po) -> bool"""
        return _datamodel.PublicObjectRingBuffer_feed(self, po)
    __swig_destroy__ = _datamodel.delete_PublicObjectRingBuffer

# Register PublicObjectRingBuffer in _datamodel:
_datamodel.PublicObjectRingBuffer_swigregister(PublicObjectRingBuffer)

class PublicObjectTimeSpanBuffer(PublicObjectCache):
    r"""Proxy of C++ Seiscomp::DataModel::PublicObjectTimeSpanBuffer 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__(PublicObjectTimeSpanBuffer self) -> PublicObjectTimeSpanBuffer
        __init__(PublicObjectTimeSpanBuffer self, DatabaseArchive ar, TimeSpan length) -> PublicObjectTimeSpanBuffer
        """
        _datamodel.PublicObjectTimeSpanBuffer_swiginit(self, _datamodel.new_PublicObjectTimeSpanBuffer(*args))

    def setTimeSpan(self, arg2):
        r"""setTimeSpan(PublicObjectTimeSpanBuffer self, TimeSpan arg2) -> bool"""
        return _datamodel.PublicObjectTimeSpanBuffer_setTimeSpan(self, arg2)

    def feed(self, po):
        r"""feed(PublicObjectTimeSpanBuffer self, PublicObject po) -> bool"""
        return _datamodel.PublicObjectTimeSpanBuffer_feed(self, po)
    __swig_destroy__ = _datamodel.delete_PublicObjectTimeSpanBuffer

# Register PublicObjectTimeSpanBuffer in _datamodel:
_datamodel.PublicObjectTimeSpanBuffer_swigregister(PublicObjectTimeSpanBuffer)

class NotifierMessage(NotifierMessageBase):
    r"""Proxy of C++ Seiscomp::DataModel::NotifierMessage 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 _datamodel.NotifierMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.NotifierMessage_TypeInfo()

    def className(self):
        r"""className(NotifierMessage self) -> char const *"""
        return _datamodel.NotifierMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(NotifierMessage self) -> RTTI"""
        return _datamodel.NotifierMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> NotifierMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> NotifierMessage
        """
        return _datamodel.NotifierMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> NotifierMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NotifierMessage
        """
        return _datamodel.NotifierMessage_ConstCast(*args)

    def __init__(self):
        r"""__init__(NotifierMessage self) -> NotifierMessage"""
        _datamodel.NotifierMessage_swiginit(self, _datamodel.new_NotifierMessage())
    __swig_destroy__ = _datamodel.delete_NotifierMessage

# Register NotifierMessage in _datamodel:
_datamodel.NotifierMessage_swigregister(NotifierMessage)

def NotifierMessage_ClassName():
    r"""NotifierMessage_ClassName() -> char const *"""
    return _datamodel.NotifierMessage_ClassName()

def NotifierMessage_TypeInfo():
    r"""NotifierMessage_TypeInfo() -> RTTI"""
    return _datamodel.NotifierMessage_TypeInfo()

def NotifierMessage_Cast(*args):
    r"""
    NotifierMessage_Cast(BaseObject o) -> NotifierMessage
    NotifierMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> NotifierMessage
    """
    return _datamodel.NotifierMessage_Cast(*args)

def NotifierMessage_ConstCast(*args):
    r"""
    NotifierMessage_ConstCast(BaseObject o) -> NotifierMessage
    NotifierMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NotifierMessage
    """
    return _datamodel.NotifierMessage_ConstCast(*args)

class Notifier(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::Notifier 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 _datamodel.Notifier_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Notifier_TypeInfo()

    def className(self):
        r"""className(Notifier self) -> char const *"""
        return _datamodel.Notifier_className(self)

    def typeInfo(self):
        r"""typeInfo(Notifier self) -> RTTI"""
        return _datamodel.Notifier_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Notifier
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Notifier
        """
        return _datamodel.Notifier_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Notifier
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Notifier
        """
        return _datamodel.Notifier_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Notifier self, GenericArchive ar)"""
        return _datamodel.Notifier_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Notifier_Meta()

    def meta(self):
        r"""meta(Notifier self) -> MetaObject"""
        return _datamodel.Notifier_meta(self)
    CR_DIFFERENT = _datamodel.Notifier_CR_DIFFERENT
    
    CR_EQUAL = _datamodel.Notifier_CR_EQUAL
    
    CR_OPPOSITE = _datamodel.Notifier_CR_OPPOSITE
    
    CR_OVERRIDE = _datamodel.Notifier_CR_OVERRIDE
    
    CR_QUANTITY = _datamodel.Notifier_CR_QUANTITY
    

    def __init__(self, parentID, arg3, object):
        r"""__init__(Notifier self, std::string const & parentID, Seiscomp::DataModel::Operation arg3, Object object) -> Notifier"""
        _datamodel.Notifier_swiginit(self, _datamodel.new_Notifier(parentID, arg3, object))
    __swig_destroy__ = _datamodel.delete_Notifier

    @staticmethod
    def Enable():
        r"""Enable()"""
        return _datamodel.Notifier_Enable()

    @staticmethod
    def Disable():
        r"""Disable()"""
        return _datamodel.Notifier_Disable()

    @staticmethod
    def SetEnabled(arg1):
        r"""SetEnabled(bool arg1)"""
        return _datamodel.Notifier_SetEnabled(arg1)

    @staticmethod
    def IsEnabled():
        r"""IsEnabled() -> bool"""
        return _datamodel.Notifier_IsEnabled()

    @staticmethod
    def SetCheckEnabled(arg1):
        r"""SetCheckEnabled(bool arg1)"""
        return _datamodel.Notifier_SetCheckEnabled(arg1)

    @staticmethod
    def IsCheckEnabled():
        r"""IsCheckEnabled() -> bool"""
        return _datamodel.Notifier_IsCheckEnabled()

    @staticmethod
    def GetMessage(allNotifier=True):
        r"""GetMessage(bool allNotifier=True) -> NotifierMessage"""
        return _datamodel.Notifier_GetMessage(allNotifier)

    @staticmethod
    def Size():
        r"""Size() -> size_t"""
        return _datamodel.Notifier_Size()

    @staticmethod
    def Clear():
        r"""Clear()"""
        return _datamodel.Notifier_Clear()

    @staticmethod
    def Create(*args):
        r"""
        Create(std::string const & parentID, Seiscomp::DataModel::Operation op, Object object) -> Notifier
        Create(PublicObject parent, Seiscomp::DataModel::Operation op, Object object) -> Notifier
        """
        return _datamodel.Notifier_Create(*args)

    def apply(self):
        r"""apply(Notifier self) -> bool"""
        return _datamodel.Notifier_apply(self)

    def setParentID(self, arg2):
        r"""setParentID(Notifier self, std::string const & arg2)"""
        return _datamodel.Notifier_setParentID(self, arg2)

    def parentID(self):
        r"""parentID(Notifier self) -> std::string const &"""
        return _datamodel.Notifier_parentID(self)

    def setOperation(self, arg2):
        r"""setOperation(Notifier self, Seiscomp::DataModel::Operation arg2)"""
        return _datamodel.Notifier_setOperation(self, arg2)

    def operation(self):
        r"""operation(Notifier self) -> Seiscomp::DataModel::Operation"""
        return _datamodel.Notifier_operation(self)

    def setObject(self, object):
        r"""setObject(Notifier self, Object object)"""
        return _datamodel.Notifier_setObject(self, object)

    def object(self):
        r"""object(Notifier self) -> Object"""
        return _datamodel.Notifier_object(self)

    def cmp(self, *args):
        r"""
        cmp(Notifier self, Notifier arg2) -> Seiscomp::DataModel::Notifier::CompareResult
        cmp(Notifier self, Notifier arg2) -> Seiscomp::DataModel::Notifier::CompareResult
        """
        return _datamodel.Notifier_cmp(self, *args)

# Register Notifier in _datamodel:
_datamodel.Notifier_swigregister(Notifier)

def Notifier_ClassName():
    r"""Notifier_ClassName() -> char const *"""
    return _datamodel.Notifier_ClassName()

def Notifier_TypeInfo():
    r"""Notifier_TypeInfo() -> RTTI"""
    return _datamodel.Notifier_TypeInfo()

def Notifier_Cast(*args):
    r"""
    Notifier_Cast(BaseObject o) -> Notifier
    Notifier_Cast(Seiscomp::Core::BaseObjectPtr o) -> Notifier
    """
    return _datamodel.Notifier_Cast(*args)

def Notifier_ConstCast(*args):
    r"""
    Notifier_ConstCast(BaseObject o) -> Notifier
    Notifier_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Notifier
    """
    return _datamodel.Notifier_ConstCast(*args)

def Notifier_Meta():
    r"""Notifier_Meta() -> MetaObject"""
    return _datamodel.Notifier_Meta()

def Notifier_Enable():
    r"""Notifier_Enable()"""
    return _datamodel.Notifier_Enable()

def Notifier_Disable():
    r"""Notifier_Disable()"""
    return _datamodel.Notifier_Disable()

def Notifier_SetEnabled(arg1):
    r"""Notifier_SetEnabled(bool arg1)"""
    return _datamodel.Notifier_SetEnabled(arg1)

def Notifier_IsEnabled():
    r"""Notifier_IsEnabled() -> bool"""
    return _datamodel.Notifier_IsEnabled()

def Notifier_SetCheckEnabled(arg1):
    r"""Notifier_SetCheckEnabled(bool arg1)"""
    return _datamodel.Notifier_SetCheckEnabled(arg1)

def Notifier_IsCheckEnabled():
    r"""Notifier_IsCheckEnabled() -> bool"""
    return _datamodel.Notifier_IsCheckEnabled()

def Notifier_GetMessage(allNotifier=True):
    r"""Notifier_GetMessage(bool allNotifier=True) -> NotifierMessage"""
    return _datamodel.Notifier_GetMessage(allNotifier)

def Notifier_Size():
    r"""Notifier_Size() -> size_t"""
    return _datamodel.Notifier_Size()

def Notifier_Clear():
    r"""Notifier_Clear()"""
    return _datamodel.Notifier_Clear()

def Notifier_Create(*args):
    r"""
    Notifier_Create(std::string const & parentID, Seiscomp::DataModel::Operation op, Object object) -> Notifier
    Notifier_Create(PublicObject parent, Seiscomp::DataModel::Operation op, Object object) -> Notifier
    """
    return _datamodel.Notifier_Create(*args)

class NotifierCreator(Visitor):
    r"""Proxy of C++ Seiscomp::DataModel::NotifierCreator 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, op):
        r"""__init__(NotifierCreator self, Seiscomp::DataModel::Operation op) -> NotifierCreator"""
        _datamodel.NotifierCreator_swiginit(self, _datamodel.new_NotifierCreator(op))

    def visit(self, *args):
        r"""
        visit(NotifierCreator self, PublicObject arg2) -> bool
        visit(NotifierCreator self, Object arg2)
        """
        return _datamodel.NotifierCreator_visit(self, *args)
    __swig_destroy__ = _datamodel.delete_NotifierCreator

# Register NotifierCreator in _datamodel:
_datamodel.NotifierCreator_swigregister(NotifierCreator)


def eventRegion(arg1):
    r"""eventRegion(Event arg1) -> std::string"""
    return _datamodel.eventRegion(arg1)
NETWORK_CODE_NOT_FOUND = _datamodel.NETWORK_CODE_NOT_FOUND

NETWORK_EPOCH_NOT_FOUND = _datamodel.NETWORK_EPOCH_NOT_FOUND

STATION_CODE_NOT_FOUND = _datamodel.STATION_CODE_NOT_FOUND

STATION_EPOCH_NOT_FOUND = _datamodel.STATION_EPOCH_NOT_FOUND

SENSOR_CODE_NOT_FOUND = _datamodel.SENSOR_CODE_NOT_FOUND

SENSOR_EPOCH_NOT_FOUND = _datamodel.SENSOR_EPOCH_NOT_FOUND

STREAM_CODE_NOT_FOUND = _datamodel.STREAM_CODE_NOT_FOUND

STREAM_EPOCH_NOT_FOUND = _datamodel.STREAM_EPOCH_NOT_FOUND

EInventoryErrorQuantity = _datamodel.EInventoryErrorQuantity

class EInventoryErrorNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EInventoryErrorNames 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__(EInventoryErrorNames self) -> EInventoryErrorNames"""
        _datamodel.EInventoryErrorNames_swiginit(self, _datamodel.new_EInventoryErrorNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EInventoryErrorNames_name(i)
    __swig_destroy__ = _datamodel.delete_EInventoryErrorNames

# Register EInventoryErrorNames in _datamodel:
_datamodel.EInventoryErrorNames_swigregister(EInventoryErrorNames)

def EInventoryErrorNames_name(i):
    r"""EInventoryErrorNames_name(int i) -> char const *"""
    return _datamodel.EInventoryErrorNames_name(i)


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

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

def getStream(*args):
    r"""
    getStream(Inventory inventory, 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 inventory, Pick pick) -> Stream
    """
    return _datamodel.getStream(*args)
class ThreeComponents(object):
    r"""Proxy of C++ Seiscomp::DataModel::ThreeComponents class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Vertical = _datamodel.ThreeComponents_Vertical
    
    FirstHorizontal = _datamodel.ThreeComponents_FirstHorizontal
    
    SecondHorizontal = _datamodel.ThreeComponents_SecondHorizontal
    

    def vertical(self):
        r"""vertical(ThreeComponents self) -> Stream"""
        return _datamodel.ThreeComponents_vertical(self)

    def firstHorizontal(self):
        r"""firstHorizontal(ThreeComponents self) -> Stream"""
        return _datamodel.ThreeComponents_firstHorizontal(self)

    def secondHorizontal(self):
        r"""secondHorizontal(ThreeComponents self) -> Stream"""
        return _datamodel.ThreeComponents_secondHorizontal(self)

    def __init__(self):
        r"""__init__(ThreeComponents self) -> ThreeComponents"""
        _datamodel.ThreeComponents_swiginit(self, _datamodel.new_ThreeComponents())
    comps = property(_datamodel.ThreeComponents_comps_get, _datamodel.ThreeComponents_comps_set, doc=r"""comps : a(3).p.Seiscomp::DataModel::Stream""")
    __swig_destroy__ = _datamodel.delete_ThreeComponents

# Register ThreeComponents in _datamodel:
_datamodel.ThreeComponents_swigregister(ThreeComponents)


def getVerticalComponent(loc, streamCode, time):
    r"""getVerticalComponent(SensorLocation loc, char const * streamCode, Time time) -> Stream"""
    return _datamodel.getVerticalComponent(loc, streamCode, time)

def getThreeComponents(res, loc, streamCode, time):
    r"""getThreeComponents(ThreeComponents res, SensorLocation loc, char const * streamCode, Time time) -> bool"""
    return _datamodel.getThreeComponents(res, loc, streamCode, time)

def findSetup(configStation, setupName, allowGlobal=True):
    r"""findSetup(ConfigStation configStation, std::string const & setupName, bool allowGlobal=True) -> Setup"""
    return _datamodel.findSetup(configStation, setupName, allowGlobal)

def copy(obj):
    r"""copy(Object obj) -> Object"""
    return _datamodel.copy(obj)

def id(*args):
    r"""
    id(Network net) -> std::string
    id(Station sta) -> std::string
    id(SensorLocation loc, char const * unsetCode="") -> std::string
    id(Stream stream, char const * unsetCode="", bool includeComponent=True) -> std::string
    """
    return _datamodel.id(*args)

def getLocation(*args):
    r"""
    getLocation(Station sta) -> GeoCoordinate
    getLocation(SensorLocation loc) -> GeoCoordinate
    getLocation(Stream stream) -> GeoCoordinate
    """
    return _datamodel.getLocation(*args)
class DiffMerge(object):
    r"""Proxy of C++ Seiscomp::DataModel::DiffMerge 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__(DiffMerge self) -> DiffMerge"""
        _datamodel.DiffMerge_swiginit(self, _datamodel.new_DiffMerge())

    def setLoggingLevel(self, level):
        r"""setLoggingLevel(DiffMerge self, int level)"""
        return _datamodel.DiffMerge_setLoggingLevel(self, level)

    def showLog(self, *args):
        r"""showLog(DiffMerge self, std::ostream & os=std::cerr, int padding=0, int indent=1, bool ignoreFirstPad=False)"""
        return _datamodel.DiffMerge_showLog(self, *args)

    def find(self, tree, node):
        r"""find(DiffMerge self, Object tree, Object node) -> Object"""
        return _datamodel.DiffMerge_find(self, tree, node)

    def diff(self, o1, o2, diffList):
        r"""diff(DiffMerge self, Object o1, Object o2, std::vector< Seiscomp::DataModel::NotifierPtr,std::allocator< Seiscomp::DataModel::NotifierPtr > > & diffList) -> bool"""
        return _datamodel.DiffMerge_diff(self, o1, o2, diffList)

    def diff2Message(self, o1, o2):
        r"""diff2Message(DiffMerge self, Object o1, Object o2) -> NotifierMessage"""
        return _datamodel.DiffMerge_diff2Message(self, o1, o2)

    def merge(self, *args):
        r"""
        merge(DiffMerge self, Object tree, Object node, std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > & idMap) -> bool
        merge(DiffMerge self, Object mergeResult, std::vector< Seiscomp::DataModel::Object *,std::allocator< Seiscomp::DataModel::Object * > > const & objects) -> bool
        """
        return _datamodel.DiffMerge_merge(self, *args)

    def validateReferences(self, o):
        r"""validateReferences(DiffMerge self, Object o) -> bool"""
        return _datamodel.DiffMerge_validateReferences(self, o)

    def mapReferences(self, o, publicIDMap):
        r"""mapReferences(DiffMerge self, Object o, std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > const & publicIDMap) -> size_t"""
        return _datamodel.DiffMerge_mapReferences(self, o, publicIDMap)

    def compareObjects(self, o1, o2):
        r"""compareObjects(DiffMerge self, Object o1, Object o2) -> bool"""
        return _datamodel.DiffMerge_compareObjects(self, o1, o2)
    __swig_destroy__ = _datamodel.delete_DiffMerge

# Register DiffMerge in _datamodel:
_datamodel.DiffMerge_swigregister(DiffMerge)

class Diff2(object):
    r"""Proxy of C++ Seiscomp::DataModel::Diff2 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__(Diff2 self) -> Diff2"""
        _datamodel.Diff2_swiginit(self, _datamodel.new_Diff2())
    __swig_destroy__ = _datamodel.delete_Diff2

    def diff2Message(self, o1, o2, o1ParentID, logNode=None):
        r"""diff2Message(Diff2 self, Object o1, Object o2, std::string const & o1ParentID, Seiscomp::DataModel::Diff2::LogNode * logNode=None) -> NotifierMessage"""
        return _datamodel.Diff2_diff2Message(self, o1, o2, o1ParentID, logNode)

# Register Diff2 in _datamodel:
_datamodel.Diff2_swigregister(Diff2)

class Diff3(Diff2):
    r"""Proxy of C++ Seiscomp::DataModel::Diff3 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
    __swig_destroy__ = _datamodel.delete_Diff3

# Register Diff3 in _datamodel:
_datamodel.Diff3_swigregister(Diff3)

class Diff4(Diff3):
    r"""Proxy of C++ Seiscomp::DataModel::Diff4 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
    __swig_destroy__ = _datamodel.delete_Diff4

# Register Diff4 in _datamodel:
_datamodel.Diff4_swigregister(Diff4)

class PublicObjectCacheIterator(object):
    r"""Proxy of C++ PublicObjectCacheIterator 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, cache):
        r"""__init__(PublicObjectCacheIterator self, PublicObjectCache cache) -> PublicObjectCacheIterator"""
        _datamodel.PublicObjectCacheIterator_swiginit(self, _datamodel.new_PublicObjectCacheIterator(cache))

    def next(self):
        r"""next(PublicObjectCacheIterator self) -> PublicObject"""
        return _datamodel.PublicObjectCacheIterator_next(self)

    def __next__(self):
        o = self.next()
        if o is None:
            raise StopIteration
        return o

    __swig_destroy__ = _datamodel.delete_PublicObjectCacheIterator

# Register PublicObjectCacheIterator in _datamodel:
_datamodel.PublicObjectCacheIterator_swigregister(PublicObjectCacheIterator)

HORIZONTAL = _datamodel.HORIZONTAL

ELLIPSE = _datamodel.ELLIPSE

ELLIPSOID = _datamodel.ELLIPSOID

PDF = _datamodel.PDF

EOriginUncertaintyDescriptionQuantity = _datamodel.EOriginUncertaintyDescriptionQuantity

class EOriginUncertaintyDescriptionNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EOriginUncertaintyDescriptionNames 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__(EOriginUncertaintyDescriptionNames self) -> EOriginUncertaintyDescriptionNames"""
        _datamodel.EOriginUncertaintyDescriptionNames_swiginit(self, _datamodel.new_EOriginUncertaintyDescriptionNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EOriginUncertaintyDescriptionNames_name(i)
    __swig_destroy__ = _datamodel.delete_EOriginUncertaintyDescriptionNames

# Register EOriginUncertaintyDescriptionNames in _datamodel:
_datamodel.EOriginUncertaintyDescriptionNames_swigregister(EOriginUncertaintyDescriptionNames)

def EOriginUncertaintyDescriptionNames_name(i):
    r"""EOriginUncertaintyDescriptionNames_name(int i) -> char const *"""
    return _datamodel.EOriginUncertaintyDescriptionNames_name(i)

CMT_S = _datamodel.CMT_S

CMT_Q = _datamodel.CMT_Q

EMomentTensorStatusQuantity = _datamodel.EMomentTensorStatusQuantity

class EMomentTensorStatusNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EMomentTensorStatusNames 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__(EMomentTensorStatusNames self) -> EMomentTensorStatusNames"""
        _datamodel.EMomentTensorStatusNames_swiginit(self, _datamodel.new_EMomentTensorStatusNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EMomentTensorStatusNames_name(i)
    __swig_destroy__ = _datamodel.delete_EMomentTensorStatusNames

# Register EMomentTensorStatusNames in _datamodel:
_datamodel.EMomentTensorStatusNames_swigregister(EMomentTensorStatusNames)

def EMomentTensorStatusNames_name(i):
    r"""EMomentTensorStatusNames_name(int i) -> char const *"""
    return _datamodel.EMomentTensorStatusNames_name(i)

FROM_LOCATION = _datamodel.FROM_LOCATION

FROM_MOMENT_TENSOR_INVERSION = _datamodel.FROM_MOMENT_TENSOR_INVERSION

BROAD_BAND_P_WAVEFORMS = _datamodel.BROAD_BAND_P_WAVEFORMS

CONSTRAINED_BY_DEPTH_PHASES = _datamodel.CONSTRAINED_BY_DEPTH_PHASES

CONSTRAINED_BY_DIRECT_PHASES = _datamodel.CONSTRAINED_BY_DIRECT_PHASES

OPERATOR_ASSIGNED = _datamodel.OPERATOR_ASSIGNED

OTHER_ORIGIN_DEPTH = _datamodel.OTHER_ORIGIN_DEPTH

EOriginDepthTypeQuantity = _datamodel.EOriginDepthTypeQuantity

class EOriginDepthTypeNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EOriginDepthTypeNames 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__(EOriginDepthTypeNames self) -> EOriginDepthTypeNames"""
        _datamodel.EOriginDepthTypeNames_swiginit(self, _datamodel.new_EOriginDepthTypeNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EOriginDepthTypeNames_name(i)
    __swig_destroy__ = _datamodel.delete_EOriginDepthTypeNames

# Register EOriginDepthTypeNames in _datamodel:
_datamodel.EOriginDepthTypeNames_swigregister(EOriginDepthTypeNames)

def EOriginDepthTypeNames_name(i):
    r"""EOriginDepthTypeNames_name(int i) -> char const *"""
    return _datamodel.EOriginDepthTypeNames_name(i)

HYPOCENTER = _datamodel.HYPOCENTER

CENTROID = _datamodel.CENTROID

AMPLITUDE = _datamodel.AMPLITUDE

MACROSEISMIC = _datamodel.MACROSEISMIC

RUPTURE_START = _datamodel.RUPTURE_START

RUPTURE_END = _datamodel.RUPTURE_END

EOriginTypeQuantity = _datamodel.EOriginTypeQuantity

class EOriginTypeNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EOriginTypeNames 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__(EOriginTypeNames self) -> EOriginTypeNames"""
        _datamodel.EOriginTypeNames_swiginit(self, _datamodel.new_EOriginTypeNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EOriginTypeNames_name(i)
    __swig_destroy__ = _datamodel.delete_EOriginTypeNames

# Register EOriginTypeNames in _datamodel:
_datamodel.EOriginTypeNames_swigregister(EOriginTypeNames)

def EOriginTypeNames_name(i):
    r"""EOriginTypeNames_name(int i) -> char const *"""
    return _datamodel.EOriginTypeNames_name(i)

MANUAL = _datamodel.MANUAL

AUTOMATIC = _datamodel.AUTOMATIC

EEvaluationModeQuantity = _datamodel.EEvaluationModeQuantity

class EEvaluationModeNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EEvaluationModeNames 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__(EEvaluationModeNames self) -> EEvaluationModeNames"""
        _datamodel.EEvaluationModeNames_swiginit(self, _datamodel.new_EEvaluationModeNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EEvaluationModeNames_name(i)
    __swig_destroy__ = _datamodel.delete_EEvaluationModeNames

# Register EEvaluationModeNames in _datamodel:
_datamodel.EEvaluationModeNames_swigregister(EEvaluationModeNames)

def EEvaluationModeNames_name(i):
    r"""EEvaluationModeNames_name(int i) -> char const *"""
    return _datamodel.EEvaluationModeNames_name(i)

PRELIMINARY = _datamodel.PRELIMINARY

CONFIRMED = _datamodel.CONFIRMED

REVIEWED = _datamodel.REVIEWED

FINAL = _datamodel.FINAL

REJECTED = _datamodel.REJECTED

REPORTED = _datamodel.REPORTED

EEvaluationStatusQuantity = _datamodel.EEvaluationStatusQuantity

class EEvaluationStatusNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EEvaluationStatusNames 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__(EEvaluationStatusNames self) -> EEvaluationStatusNames"""
        _datamodel.EEvaluationStatusNames_swiginit(self, _datamodel.new_EEvaluationStatusNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EEvaluationStatusNames_name(i)
    __swig_destroy__ = _datamodel.delete_EEvaluationStatusNames

# Register EEvaluationStatusNames in _datamodel:
_datamodel.EEvaluationStatusNames_swigregister(EEvaluationStatusNames)

def EEvaluationStatusNames_name(i):
    r"""EEvaluationStatusNames_name(int i) -> char const *"""
    return _datamodel.EEvaluationStatusNames_name(i)

EMERGENT = _datamodel.EMERGENT

IMPULSIVE = _datamodel.IMPULSIVE

QUESTIONABLE = _datamodel.QUESTIONABLE

EPickOnsetQuantity = _datamodel.EPickOnsetQuantity

class EPickOnsetNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EPickOnsetNames 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__(EPickOnsetNames self) -> EPickOnsetNames"""
        _datamodel.EPickOnsetNames_swiginit(self, _datamodel.new_EPickOnsetNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EPickOnsetNames_name(i)
    __swig_destroy__ = _datamodel.delete_EPickOnsetNames

# Register EPickOnsetNames in _datamodel:
_datamodel.EPickOnsetNames_swigregister(EPickOnsetNames)

def EPickOnsetNames_name(i):
    r"""EPickOnsetNames_name(int i) -> char const *"""
    return _datamodel.EPickOnsetNames_name(i)

CMT_0 = _datamodel.CMT_0

CMT_1 = _datamodel.CMT_1

CMT_2 = _datamodel.CMT_2

TELESEISMIC = _datamodel.TELESEISMIC

REGIONAL = _datamodel.REGIONAL

EMomentTensorMethodQuantity = _datamodel.EMomentTensorMethodQuantity

class EMomentTensorMethodNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EMomentTensorMethodNames 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__(EMomentTensorMethodNames self) -> EMomentTensorMethodNames"""
        _datamodel.EMomentTensorMethodNames_swiginit(self, _datamodel.new_EMomentTensorMethodNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EMomentTensorMethodNames_name(i)
    __swig_destroy__ = _datamodel.delete_EMomentTensorMethodNames

# Register EMomentTensorMethodNames in _datamodel:
_datamodel.EMomentTensorMethodNames_swigregister(EMomentTensorMethodNames)

def EMomentTensorMethodNames_name(i):
    r"""EMomentTensorMethodNames_name(int i) -> char const *"""
    return _datamodel.EMomentTensorMethodNames_name(i)

BODY_WAVES = _datamodel.BODY_WAVES

P_BODY_WAVES = _datamodel.P_BODY_WAVES

LONG_PERIOD_BODY_WAVES = _datamodel.LONG_PERIOD_BODY_WAVES

SURFACE_WAVES = _datamodel.SURFACE_WAVES

INTERMEDIATE_PERIOD_SURFACE_WAVES = _datamodel.INTERMEDIATE_PERIOD_SURFACE_WAVES

LONG_PERIOD_MANTLE_WAVES = _datamodel.LONG_PERIOD_MANTLE_WAVES

UNKNOWN_WAVETYPE = _datamodel.UNKNOWN_WAVETYPE

EDataUsedWaveTypeQuantity = _datamodel.EDataUsedWaveTypeQuantity

class EDataUsedWaveTypeNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EDataUsedWaveTypeNames 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__(EDataUsedWaveTypeNames self) -> EDataUsedWaveTypeNames"""
        _datamodel.EDataUsedWaveTypeNames_swiginit(self, _datamodel.new_EDataUsedWaveTypeNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EDataUsedWaveTypeNames_name(i)
    __swig_destroy__ = _datamodel.delete_EDataUsedWaveTypeNames

# Register EDataUsedWaveTypeNames in _datamodel:
_datamodel.EDataUsedWaveTypeNames_swigregister(EDataUsedWaveTypeNames)

def EDataUsedWaveTypeNames_name(i):
    r"""EDataUsedWaveTypeNames_name(int i) -> char const *"""
    return _datamodel.EDataUsedWaveTypeNames_name(i)

FELT_REPORT = _datamodel.FELT_REPORT

FLINN_ENGDAHL_REGION = _datamodel.FLINN_ENGDAHL_REGION

LOCAL_TIME = _datamodel.LOCAL_TIME

TECTONIC_SUMMARY = _datamodel.TECTONIC_SUMMARY

NEAREST_CITIES = _datamodel.NEAREST_CITIES

EARTHQUAKE_NAME = _datamodel.EARTHQUAKE_NAME

REGION_NAME = _datamodel.REGION_NAME

EEventDescriptionTypeQuantity = _datamodel.EEventDescriptionTypeQuantity

class EEventDescriptionTypeNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EEventDescriptionTypeNames 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__(EEventDescriptionTypeNames self) -> EEventDescriptionTypeNames"""
        _datamodel.EEventDescriptionTypeNames_swiginit(self, _datamodel.new_EEventDescriptionTypeNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EEventDescriptionTypeNames_name(i)
    __swig_destroy__ = _datamodel.delete_EEventDescriptionTypeNames

# Register EEventDescriptionTypeNames in _datamodel:
_datamodel.EEventDescriptionTypeNames_swigregister(EEventDescriptionTypeNames)

def EEventDescriptionTypeNames_name(i):
    r"""EEventDescriptionTypeNames_name(int i) -> char const *"""
    return _datamodel.EEventDescriptionTypeNames_name(i)

NOT_EXISTING = _datamodel.NOT_EXISTING

NOT_LOCATABLE = _datamodel.NOT_LOCATABLE

OUTSIDE_OF_NETWORK_INTEREST = _datamodel.OUTSIDE_OF_NETWORK_INTEREST

EARTHQUAKE = _datamodel.EARTHQUAKE

INDUCED_EARTHQUAKE = _datamodel.INDUCED_EARTHQUAKE

QUARRY_BLAST = _datamodel.QUARRY_BLAST

EXPLOSION = _datamodel.EXPLOSION

CHEMICAL_EXPLOSION = _datamodel.CHEMICAL_EXPLOSION

NUCLEAR_EXPLOSION = _datamodel.NUCLEAR_EXPLOSION

LANDSLIDE = _datamodel.LANDSLIDE

ROCKSLIDE = _datamodel.ROCKSLIDE

SNOW_AVALANCHE = _datamodel.SNOW_AVALANCHE

DEBRIS_AVALANCHE = _datamodel.DEBRIS_AVALANCHE

MINE_COLLAPSE = _datamodel.MINE_COLLAPSE

BUILDING_COLLAPSE = _datamodel.BUILDING_COLLAPSE

VOLCANIC_ERUPTION = _datamodel.VOLCANIC_ERUPTION

METEOR_IMPACT = _datamodel.METEOR_IMPACT

PLANE_CRASH = _datamodel.PLANE_CRASH

SONIC_BOOM = _datamodel.SONIC_BOOM

DUPLICATE = _datamodel.DUPLICATE

OTHER_EVENT = _datamodel.OTHER_EVENT

NOT_REPORTED = _datamodel.NOT_REPORTED

ANTHROPOGENIC_EVENT = _datamodel.ANTHROPOGENIC_EVENT

COLLAPSE = _datamodel.COLLAPSE

CAVITY_COLLAPSE = _datamodel.CAVITY_COLLAPSE

ACCIDENTAL_EXPLOSION = _datamodel.ACCIDENTAL_EXPLOSION

CONTROLLED_EXPLOSION = _datamodel.CONTROLLED_EXPLOSION

EXPERIMENTAL_EXPLOSION = _datamodel.EXPERIMENTAL_EXPLOSION

INDUSTRIAL_EXPLOSION = _datamodel.INDUSTRIAL_EXPLOSION

MINING_EXPLOSION = _datamodel.MINING_EXPLOSION

ROAD_CUT = _datamodel.ROAD_CUT

BLASTING_LEVEE = _datamodel.BLASTING_LEVEE

INDUCED_OR_TRIGGERED_EVENT = _datamodel.INDUCED_OR_TRIGGERED_EVENT

ROCK_BURST = _datamodel.ROCK_BURST

RESERVOIR_LOADING = _datamodel.RESERVOIR_LOADING

FLUID_INJECTION = _datamodel.FLUID_INJECTION

FLUID_EXTRACTION = _datamodel.FLUID_EXTRACTION

CRASH = _datamodel.CRASH

TRAIN_CRASH = _datamodel.TRAIN_CRASH

BOAT_CRASH = _datamodel.BOAT_CRASH

ATMOSPHERIC_EVENT = _datamodel.ATMOSPHERIC_EVENT

SONIC_BLAST = _datamodel.SONIC_BLAST

ACOUSTIC_NOISE = _datamodel.ACOUSTIC_NOISE

THUNDER = _datamodel.THUNDER

AVALANCHE = _datamodel.AVALANCHE

HYDROACOUSTIC_EVENT = _datamodel.HYDROACOUSTIC_EVENT

ICE_QUAKE = _datamodel.ICE_QUAKE

SLIDE = _datamodel.SLIDE

METEORITE = _datamodel.METEORITE

CALVING = _datamodel.CALVING

FROST_QUAKE = _datamodel.FROST_QUAKE

TREMOR_PULSE = _datamodel.TREMOR_PULSE

SUBMARINE_LANDSLIDE = _datamodel.SUBMARINE_LANDSLIDE

ROCKET_LAUNCH = _datamodel.ROCKET_LAUNCH

ROCKET = _datamodel.ROCKET

ROCKET_IMPACT = _datamodel.ROCKET_IMPACT

ARTILLERY_STRIKE = _datamodel.ARTILLERY_STRIKE

BOMB_DETONATION = _datamodel.BOMB_DETONATION

MOVING_AIRCRAFT = _datamodel.MOVING_AIRCRAFT

ATMOSPHERIC_METEOR_EXPLOSION = _datamodel.ATMOSPHERIC_METEOR_EXPLOSION

EEventTypeQuantity = _datamodel.EEventTypeQuantity

class EEventTypeNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EEventTypeNames 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__(EEventTypeNames self) -> EEventTypeNames"""
        _datamodel.EEventTypeNames_swiginit(self, _datamodel.new_EEventTypeNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EEventTypeNames_name(i)
    __swig_destroy__ = _datamodel.delete_EEventTypeNames

# Register EEventTypeNames in _datamodel:
_datamodel.EEventTypeNames_swigregister(EEventTypeNames)

def EEventTypeNames_name(i):
    r"""EEventTypeNames_name(int i) -> char const *"""
    return _datamodel.EEventTypeNames_name(i)

KNOWN = _datamodel.KNOWN

SUSPECTED = _datamodel.SUSPECTED

DAMAGING = _datamodel.DAMAGING

FELT = _datamodel.FELT

EEventTypeCertaintyQuantity = _datamodel.EEventTypeCertaintyQuantity

class EEventTypeCertaintyNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EEventTypeCertaintyNames 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__(EEventTypeCertaintyNames self) -> EEventTypeCertaintyNames"""
        _datamodel.EEventTypeCertaintyNames_swiginit(self, _datamodel.new_EEventTypeCertaintyNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EEventTypeCertaintyNames_name(i)
    __swig_destroy__ = _datamodel.delete_EEventTypeCertaintyNames

# Register EEventTypeCertaintyNames in _datamodel:
_datamodel.EEventTypeCertaintyNames_swigregister(EEventTypeCertaintyNames)

def EEventTypeCertaintyNames_name(i):
    r"""EEventTypeCertaintyNames_name(int i) -> char const *"""
    return _datamodel.EEventTypeCertaintyNames_name(i)

BOX_CAR = _datamodel.BOX_CAR

TRIANGLE = _datamodel.TRIANGLE

TRAPEZOID = _datamodel.TRAPEZOID

UNKNOWN_FUNCTION = _datamodel.UNKNOWN_FUNCTION

ESourceTimeFunctionTypeQuantity = _datamodel.ESourceTimeFunctionTypeQuantity

class ESourceTimeFunctionTypeNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::ESourceTimeFunctionTypeNames 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__(ESourceTimeFunctionTypeNames self) -> ESourceTimeFunctionTypeNames"""
        _datamodel.ESourceTimeFunctionTypeNames_swiginit(self, _datamodel.new_ESourceTimeFunctionTypeNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.ESourceTimeFunctionTypeNames_name(i)
    __swig_destroy__ = _datamodel.delete_ESourceTimeFunctionTypeNames

# Register ESourceTimeFunctionTypeNames in _datamodel:
_datamodel.ESourceTimeFunctionTypeNames_swigregister(ESourceTimeFunctionTypeNames)

def ESourceTimeFunctionTypeNames_name(i):
    r"""ESourceTimeFunctionTypeNames_name(int i) -> char const *"""
    return _datamodel.ESourceTimeFunctionTypeNames_name(i)

POSITIVE = _datamodel.POSITIVE

NEGATIVE = _datamodel.NEGATIVE

UNDECIDABLE = _datamodel.UNDECIDABLE

EPickPolarityQuantity = _datamodel.EPickPolarityQuantity

class EPickPolarityNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EPickPolarityNames 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__(EPickPolarityNames self) -> EPickPolarityNames"""
        _datamodel.EPickPolarityNames_swiginit(self, _datamodel.new_EPickPolarityNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EPickPolarityNames_name(i)
    __swig_destroy__ = _datamodel.delete_EPickPolarityNames

# Register EPickPolarityNames in _datamodel:
_datamodel.EPickPolarityNames_swigregister(EPickPolarityNames)

def EPickPolarityNames_name(i):
    r"""EPickPolarityNames_name(int i) -> char const *"""
    return _datamodel.EPickPolarityNames_name(i)

DEPLOYMENT = _datamodel.DEPLOYMENT

ARRAY = _datamodel.ARRAY

EStationGroupTypeQuantity = _datamodel.EStationGroupTypeQuantity

class EStationGroupTypeNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::EStationGroupTypeNames 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__(EStationGroupTypeNames self) -> EStationGroupTypeNames"""
        _datamodel.EStationGroupTypeNames_swiginit(self, _datamodel.new_EStationGroupTypeNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _datamodel.EStationGroupTypeNames_name(i)
    __swig_destroy__ = _datamodel.delete_EStationGroupTypeNames

# Register EStationGroupTypeNames in _datamodel:
_datamodel.EStationGroupTypeNames_swigregister(EStationGroupTypeNames)

def EStationGroupTypeNames_name(i):
    r"""EStationGroupTypeNames_name(int i) -> char const *"""
    return _datamodel.EStationGroupTypeNames_name(i)

class RealArray(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::RealArray 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 _datamodel.RealArray_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.RealArray_TypeInfo()

    def className(self):
        r"""className(RealArray self) -> char const *"""
        return _datamodel.RealArray_className(self)

    def typeInfo(self):
        r"""typeInfo(RealArray self) -> RTTI"""
        return _datamodel.RealArray_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> RealArray
        Cast(Seiscomp::Core::BaseObjectPtr o) -> RealArray
        """
        return _datamodel.RealArray_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> RealArray
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealArray
        """
        return _datamodel.RealArray_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(RealArray self, GenericArchive ar)"""
        return _datamodel.RealArray_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.RealArray_Meta()

    def meta(self):
        r"""meta(RealArray self) -> MetaObject"""
        return _datamodel.RealArray_meta(self)

    def __init__(self, *args):
        r"""
        __init__(RealArray self) -> RealArray
        __init__(RealArray self, RealArray other) -> RealArray
        """
        _datamodel.RealArray_swiginit(self, _datamodel.new_RealArray(*args))
    __swig_destroy__ = _datamodel.delete_RealArray

    def __eq__(self, other):
        r"""__eq__(RealArray self, RealArray other) -> bool"""
        return _datamodel.RealArray___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(RealArray self, RealArray other) -> bool"""
        return _datamodel.RealArray___ne__(self, other)

    def equal(self, other):
        r"""equal(RealArray self, RealArray other) -> bool"""
        return _datamodel.RealArray_equal(self, other)

    def setContent(self, arg2):
        r"""setContent(RealArray self, vectord arg2)"""
        return _datamodel.RealArray_setContent(self, arg2)

    def content(self, *args):
        r"""
        content(RealArray self) -> vectord
        content(RealArray self) -> vectord
        """
        return _datamodel.RealArray_content(self, *args)

# Register RealArray in _datamodel:
_datamodel.RealArray_swigregister(RealArray)

def RealArray_ClassName():
    r"""RealArray_ClassName() -> char const *"""
    return _datamodel.RealArray_ClassName()

def RealArray_TypeInfo():
    r"""RealArray_TypeInfo() -> RTTI"""
    return _datamodel.RealArray_TypeInfo()

def RealArray_Cast(*args):
    r"""
    RealArray_Cast(BaseObject o) -> RealArray
    RealArray_Cast(Seiscomp::Core::BaseObjectPtr o) -> RealArray
    """
    return _datamodel.RealArray_Cast(*args)

def RealArray_ConstCast(*args):
    r"""
    RealArray_ConstCast(BaseObject o) -> RealArray
    RealArray_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealArray
    """
    return _datamodel.RealArray_ConstCast(*args)

def RealArray_Meta():
    r"""RealArray_Meta() -> MetaObject"""
    return _datamodel.RealArray_Meta()

class TimeArray(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::TimeArray 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 _datamodel.TimeArray_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.TimeArray_TypeInfo()

    def className(self):
        r"""className(TimeArray self) -> char const *"""
        return _datamodel.TimeArray_className(self)

    def typeInfo(self):
        r"""typeInfo(TimeArray self) -> RTTI"""
        return _datamodel.TimeArray_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> TimeArray
        Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeArray
        """
        return _datamodel.TimeArray_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> TimeArray
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeArray
        """
        return _datamodel.TimeArray_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(TimeArray self, GenericArchive ar)"""
        return _datamodel.TimeArray_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.TimeArray_Meta()

    def meta(self):
        r"""meta(TimeArray self) -> MetaObject"""
        return _datamodel.TimeArray_meta(self)

    def __init__(self, *args):
        r"""
        __init__(TimeArray self) -> TimeArray
        __init__(TimeArray self, TimeArray other) -> TimeArray
        """
        _datamodel.TimeArray_swiginit(self, _datamodel.new_TimeArray(*args))
    __swig_destroy__ = _datamodel.delete_TimeArray

    def __eq__(self, other):
        r"""__eq__(TimeArray self, TimeArray other) -> bool"""
        return _datamodel.TimeArray___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(TimeArray self, TimeArray other) -> bool"""
        return _datamodel.TimeArray___ne__(self, other)

    def equal(self, other):
        r"""equal(TimeArray self, TimeArray other) -> bool"""
        return _datamodel.TimeArray_equal(self, other)

    def setContent(self, arg2):
        r"""setContent(TimeArray self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > const & arg2)"""
        return _datamodel.TimeArray_setContent(self, arg2)

    def content(self, *args):
        r"""
        content(TimeArray self) -> std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > const
        content(TimeArray self) -> std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > &
        """
        return _datamodel.TimeArray_content(self, *args)

# Register TimeArray in _datamodel:
_datamodel.TimeArray_swigregister(TimeArray)

def TimeArray_ClassName():
    r"""TimeArray_ClassName() -> char const *"""
    return _datamodel.TimeArray_ClassName()

def TimeArray_TypeInfo():
    r"""TimeArray_TypeInfo() -> RTTI"""
    return _datamodel.TimeArray_TypeInfo()

def TimeArray_Cast(*args):
    r"""
    TimeArray_Cast(BaseObject o) -> TimeArray
    TimeArray_Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeArray
    """
    return _datamodel.TimeArray_Cast(*args)

def TimeArray_ConstCast(*args):
    r"""
    TimeArray_ConstCast(BaseObject o) -> TimeArray
    TimeArray_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeArray
    """
    return _datamodel.TimeArray_ConstCast(*args)

def TimeArray_Meta():
    r"""TimeArray_Meta() -> MetaObject"""
    return _datamodel.TimeArray_Meta()

class TimePDF1D(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::TimePDF1D 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 _datamodel.TimePDF1D_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.TimePDF1D_TypeInfo()

    def className(self):
        r"""className(TimePDF1D self) -> char const *"""
        return _datamodel.TimePDF1D_className(self)

    def typeInfo(self):
        r"""typeInfo(TimePDF1D self) -> RTTI"""
        return _datamodel.TimePDF1D_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> TimePDF1D
        Cast(Seiscomp::Core::BaseObjectPtr o) -> TimePDF1D
        """
        return _datamodel.TimePDF1D_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> TimePDF1D
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimePDF1D
        """
        return _datamodel.TimePDF1D_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(TimePDF1D self, GenericArchive ar)"""
        return _datamodel.TimePDF1D_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.TimePDF1D_Meta()

    def meta(self):
        r"""meta(TimePDF1D self) -> MetaObject"""
        return _datamodel.TimePDF1D_meta(self)

    def __init__(self, *args):
        r"""
        __init__(TimePDF1D self) -> TimePDF1D
        __init__(TimePDF1D self, TimePDF1D other) -> TimePDF1D
        """
        _datamodel.TimePDF1D_swiginit(self, _datamodel.new_TimePDF1D(*args))
    __swig_destroy__ = _datamodel.delete_TimePDF1D

    def __eq__(self, other):
        r"""__eq__(TimePDF1D self, TimePDF1D other) -> bool"""
        return _datamodel.TimePDF1D___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(TimePDF1D self, TimePDF1D other) -> bool"""
        return _datamodel.TimePDF1D___ne__(self, other)

    def equal(self, other):
        r"""equal(TimePDF1D self, TimePDF1D other) -> bool"""
        return _datamodel.TimePDF1D_equal(self, other)

    def setVariable(self, variable):
        r"""setVariable(TimePDF1D self, TimeArray variable)"""
        return _datamodel.TimePDF1D_setVariable(self, variable)

    def variable(self, *args):
        r"""
        variable(TimePDF1D self) -> TimeArray
        variable(TimePDF1D self) -> TimeArray
        """
        return _datamodel.TimePDF1D_variable(self, *args)

    def setProbability(self, probability):
        r"""setProbability(TimePDF1D self, RealArray probability)"""
        return _datamodel.TimePDF1D_setProbability(self, probability)

    def probability(self, *args):
        r"""
        probability(TimePDF1D self) -> RealArray
        probability(TimePDF1D self) -> RealArray
        """
        return _datamodel.TimePDF1D_probability(self, *args)

# Register TimePDF1D in _datamodel:
_datamodel.TimePDF1D_swigregister(TimePDF1D)

def TimePDF1D_ClassName():
    r"""TimePDF1D_ClassName() -> char const *"""
    return _datamodel.TimePDF1D_ClassName()

def TimePDF1D_TypeInfo():
    r"""TimePDF1D_TypeInfo() -> RTTI"""
    return _datamodel.TimePDF1D_TypeInfo()

def TimePDF1D_Cast(*args):
    r"""
    TimePDF1D_Cast(BaseObject o) -> TimePDF1D
    TimePDF1D_Cast(Seiscomp::Core::BaseObjectPtr o) -> TimePDF1D
    """
    return _datamodel.TimePDF1D_Cast(*args)

def TimePDF1D_ConstCast(*args):
    r"""
    TimePDF1D_ConstCast(BaseObject o) -> TimePDF1D
    TimePDF1D_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimePDF1D
    """
    return _datamodel.TimePDF1D_ConstCast(*args)

def TimePDF1D_Meta():
    r"""TimePDF1D_Meta() -> MetaObject"""
    return _datamodel.TimePDF1D_Meta()

class TimeQuantity(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::TimeQuantity 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 _datamodel.TimeQuantity_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.TimeQuantity_TypeInfo()

    def className(self):
        r"""className(TimeQuantity self) -> char const *"""
        return _datamodel.TimeQuantity_className(self)

    def typeInfo(self):
        r"""typeInfo(TimeQuantity self) -> RTTI"""
        return _datamodel.TimeQuantity_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> TimeQuantity
        Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeQuantity
        """
        return _datamodel.TimeQuantity_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> TimeQuantity
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeQuantity
        """
        return _datamodel.TimeQuantity_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(TimeQuantity self, GenericArchive ar)"""
        return _datamodel.TimeQuantity_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.TimeQuantity_Meta()

    def meta(self):
        r"""meta(TimeQuantity self) -> MetaObject"""
        return _datamodel.TimeQuantity_meta(self)

    def __init__(self, *args):
        r"""
        __init__(TimeQuantity self) -> TimeQuantity
        __init__(TimeQuantity self, TimeQuantity other) -> TimeQuantity
        __init__(TimeQuantity self, Time value, Seiscomp::Core::Optional< double >::Impl const & uncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel=Unset, Seiscomp::Core::Optional< Seiscomp::DataModel::TimePDF1D >::Impl const & pdf=Unset) -> TimeQuantity
        """
        _datamodel.TimeQuantity_swiginit(self, _datamodel.new_TimeQuantity(*args))
    __swig_destroy__ = _datamodel.delete_TimeQuantity

    def __eq__(self, other):
        r"""__eq__(TimeQuantity self, TimeQuantity other) -> bool"""
        return _datamodel.TimeQuantity___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(TimeQuantity self, TimeQuantity other) -> bool"""
        return _datamodel.TimeQuantity___ne__(self, other)

    def equal(self, other):
        r"""equal(TimeQuantity self, TimeQuantity other) -> bool"""
        return _datamodel.TimeQuantity_equal(self, other)

    def setValue(self, value):
        r"""setValue(TimeQuantity self, Time value)"""
        return _datamodel.TimeQuantity_setValue(self, value)

    def value(self):
        r"""value(TimeQuantity self) -> Time"""
        return _datamodel.TimeQuantity_value(self)

    def setUncertainty(self, uncertainty):
        r"""setUncertainty(TimeQuantity self, Seiscomp::Core::Optional< double >::Impl const & uncertainty)"""
        return _datamodel.TimeQuantity_setUncertainty(self, uncertainty)

    def uncertainty(self):
        r"""uncertainty(TimeQuantity self) -> double"""
        return _datamodel.TimeQuantity_uncertainty(self)

    def setLowerUncertainty(self, lowerUncertainty):
        r"""setLowerUncertainty(TimeQuantity self, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty)"""
        return _datamodel.TimeQuantity_setLowerUncertainty(self, lowerUncertainty)

    def lowerUncertainty(self):
        r"""lowerUncertainty(TimeQuantity self) -> double"""
        return _datamodel.TimeQuantity_lowerUncertainty(self)

    def setUpperUncertainty(self, upperUncertainty):
        r"""setUpperUncertainty(TimeQuantity self, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty)"""
        return _datamodel.TimeQuantity_setUpperUncertainty(self, upperUncertainty)

    def upperUncertainty(self):
        r"""upperUncertainty(TimeQuantity self) -> double"""
        return _datamodel.TimeQuantity_upperUncertainty(self)

    def setConfidenceLevel(self, confidenceLevel):
        r"""setConfidenceLevel(TimeQuantity self, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel)"""
        return _datamodel.TimeQuantity_setConfidenceLevel(self, confidenceLevel)

    def confidenceLevel(self):
        r"""confidenceLevel(TimeQuantity self) -> double"""
        return _datamodel.TimeQuantity_confidenceLevel(self)

    def setPdf(self, pdf):
        r"""setPdf(TimeQuantity self, Seiscomp::Core::Optional< Seiscomp::DataModel::TimePDF1D >::Impl const & pdf)"""
        return _datamodel.TimeQuantity_setPdf(self, pdf)

    def pdf(self, *args):
        r"""
        pdf(TimeQuantity self) -> TimePDF1D
        pdf(TimeQuantity self) -> TimePDF1D
        """
        return _datamodel.TimeQuantity_pdf(self, *args)

# Register TimeQuantity in _datamodel:
_datamodel.TimeQuantity_swigregister(TimeQuantity)

def TimeQuantity_ClassName():
    r"""TimeQuantity_ClassName() -> char const *"""
    return _datamodel.TimeQuantity_ClassName()

def TimeQuantity_TypeInfo():
    r"""TimeQuantity_TypeInfo() -> RTTI"""
    return _datamodel.TimeQuantity_TypeInfo()

def TimeQuantity_Cast(*args):
    r"""
    TimeQuantity_Cast(BaseObject o) -> TimeQuantity
    TimeQuantity_Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeQuantity
    """
    return _datamodel.TimeQuantity_Cast(*args)

def TimeQuantity_ConstCast(*args):
    r"""
    TimeQuantity_ConstCast(BaseObject o) -> TimeQuantity
    TimeQuantity_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeQuantity
    """
    return _datamodel.TimeQuantity_ConstCast(*args)

def TimeQuantity_Meta():
    r"""TimeQuantity_Meta() -> MetaObject"""
    return _datamodel.TimeQuantity_Meta()

class CreationInfo(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::CreationInfo 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 _datamodel.CreationInfo_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.CreationInfo_TypeInfo()

    def className(self):
        r"""className(CreationInfo self) -> char const *"""
        return _datamodel.CreationInfo_className(self)

    def typeInfo(self):
        r"""typeInfo(CreationInfo self) -> RTTI"""
        return _datamodel.CreationInfo_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> CreationInfo
        Cast(Seiscomp::Core::BaseObjectPtr o) -> CreationInfo
        """
        return _datamodel.CreationInfo_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> CreationInfo
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> CreationInfo
        """
        return _datamodel.CreationInfo_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(CreationInfo self, GenericArchive ar)"""
        return _datamodel.CreationInfo_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.CreationInfo_Meta()

    def meta(self):
        r"""meta(CreationInfo self) -> MetaObject"""
        return _datamodel.CreationInfo_meta(self)

    def __init__(self, *args):
        r"""
        __init__(CreationInfo self) -> CreationInfo
        __init__(CreationInfo self, CreationInfo other) -> CreationInfo
        """
        _datamodel.CreationInfo_swiginit(self, _datamodel.new_CreationInfo(*args))
    __swig_destroy__ = _datamodel.delete_CreationInfo

    def __eq__(self, other):
        r"""__eq__(CreationInfo self, CreationInfo other) -> bool"""
        return _datamodel.CreationInfo___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(CreationInfo self, CreationInfo other) -> bool"""
        return _datamodel.CreationInfo___ne__(self, other)

    def equal(self, other):
        r"""equal(CreationInfo self, CreationInfo other) -> bool"""
        return _datamodel.CreationInfo_equal(self, other)

    def setAgencyID(self, agencyID):
        r"""setAgencyID(CreationInfo self, std::string const & agencyID)"""
        return _datamodel.CreationInfo_setAgencyID(self, agencyID)

    def agencyID(self):
        r"""agencyID(CreationInfo self) -> std::string const &"""
        return _datamodel.CreationInfo_agencyID(self)

    def setAgencyURI(self, agencyURI):
        r"""setAgencyURI(CreationInfo self, std::string const & agencyURI)"""
        return _datamodel.CreationInfo_setAgencyURI(self, agencyURI)

    def agencyURI(self):
        r"""agencyURI(CreationInfo self) -> std::string const &"""
        return _datamodel.CreationInfo_agencyURI(self)

    def setAuthor(self, author):
        r"""setAuthor(CreationInfo self, std::string const & author)"""
        return _datamodel.CreationInfo_setAuthor(self, author)

    def author(self):
        r"""author(CreationInfo self) -> std::string const &"""
        return _datamodel.CreationInfo_author(self)

    def setAuthorURI(self, authorURI):
        r"""setAuthorURI(CreationInfo self, std::string const & authorURI)"""
        return _datamodel.CreationInfo_setAuthorURI(self, authorURI)

    def authorURI(self):
        r"""authorURI(CreationInfo self) -> std::string const &"""
        return _datamodel.CreationInfo_authorURI(self)

    def setCreationTime(self, creationTime):
        r"""setCreationTime(CreationInfo self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & creationTime)"""
        return _datamodel.CreationInfo_setCreationTime(self, creationTime)

    def creationTime(self):
        r"""creationTime(CreationInfo self) -> Time"""
        return _datamodel.CreationInfo_creationTime(self)

    def setModificationTime(self, modificationTime):
        r"""setModificationTime(CreationInfo self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & modificationTime)"""
        return _datamodel.CreationInfo_setModificationTime(self, modificationTime)

    def modificationTime(self):
        r"""modificationTime(CreationInfo self) -> Time"""
        return _datamodel.CreationInfo_modificationTime(self)

    def setVersion(self, version):
        r"""setVersion(CreationInfo self, std::string const & version)"""
        return _datamodel.CreationInfo_setVersion(self, version)

    def version(self):
        r"""version(CreationInfo self) -> std::string const &"""
        return _datamodel.CreationInfo_version(self)

# Register CreationInfo in _datamodel:
_datamodel.CreationInfo_swigregister(CreationInfo)

def CreationInfo_ClassName():
    r"""CreationInfo_ClassName() -> char const *"""
    return _datamodel.CreationInfo_ClassName()

def CreationInfo_TypeInfo():
    r"""CreationInfo_TypeInfo() -> RTTI"""
    return _datamodel.CreationInfo_TypeInfo()

def CreationInfo_Cast(*args):
    r"""
    CreationInfo_Cast(BaseObject o) -> CreationInfo
    CreationInfo_Cast(Seiscomp::Core::BaseObjectPtr o) -> CreationInfo
    """
    return _datamodel.CreationInfo_Cast(*args)

def CreationInfo_ConstCast(*args):
    r"""
    CreationInfo_ConstCast(BaseObject o) -> CreationInfo
    CreationInfo_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> CreationInfo
    """
    return _datamodel.CreationInfo_ConstCast(*args)

def CreationInfo_Meta():
    r"""CreationInfo_Meta() -> MetaObject"""
    return _datamodel.CreationInfo_Meta()

class Phase(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::Phase 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 _datamodel.Phase_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Phase_TypeInfo()

    def className(self):
        r"""className(Phase self) -> char const *"""
        return _datamodel.Phase_className(self)

    def typeInfo(self):
        r"""typeInfo(Phase self) -> RTTI"""
        return _datamodel.Phase_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Phase
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Phase
        """
        return _datamodel.Phase_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Phase
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Phase
        """
        return _datamodel.Phase_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Phase self, GenericArchive ar)"""
        return _datamodel.Phase_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Phase_Meta()

    def meta(self):
        r"""meta(Phase self) -> MetaObject"""
        return _datamodel.Phase_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Phase self) -> Phase
        __init__(Phase self, Phase other) -> Phase
        __init__(Phase self, std::string const & code) -> Phase
        """
        _datamodel.Phase_swiginit(self, _datamodel.new_Phase(*args))
    __swig_destroy__ = _datamodel.delete_Phase

    def __eq__(self, other):
        r"""__eq__(Phase self, Phase other) -> bool"""
        return _datamodel.Phase___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Phase self, Phase other) -> bool"""
        return _datamodel.Phase___ne__(self, other)

    def equal(self, other):
        r"""equal(Phase self, Phase other) -> bool"""
        return _datamodel.Phase_equal(self, other)

    def setCode(self, code):
        r"""setCode(Phase self, std::string const & code)"""
        return _datamodel.Phase_setCode(self, code)

    def code(self):
        r"""code(Phase self) -> std::string const &"""
        return _datamodel.Phase_code(self)

# Register Phase in _datamodel:
_datamodel.Phase_swigregister(Phase)

def Phase_ClassName():
    r"""Phase_ClassName() -> char const *"""
    return _datamodel.Phase_ClassName()

def Phase_TypeInfo():
    r"""Phase_TypeInfo() -> RTTI"""
    return _datamodel.Phase_TypeInfo()

def Phase_Cast(*args):
    r"""
    Phase_Cast(BaseObject o) -> Phase
    Phase_Cast(Seiscomp::Core::BaseObjectPtr o) -> Phase
    """
    return _datamodel.Phase_Cast(*args)

def Phase_ConstCast(*args):
    r"""
    Phase_ConstCast(BaseObject o) -> Phase
    Phase_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Phase
    """
    return _datamodel.Phase_ConstCast(*args)

def Phase_Meta():
    r"""Phase_Meta() -> MetaObject"""
    return _datamodel.Phase_Meta()

class CommentIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::CommentIndex 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__(CommentIndex self) -> CommentIndex
        __init__(CommentIndex self, std::string const & id) -> CommentIndex
        __init__(CommentIndex self, CommentIndex arg2) -> CommentIndex
        """
        _datamodel.CommentIndex_swiginit(self, _datamodel.new_CommentIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(CommentIndex self, CommentIndex arg2) -> bool"""
        return _datamodel.CommentIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(CommentIndex self, CommentIndex arg2) -> bool"""
        return _datamodel.CommentIndex___ne__(self, arg2)
    id = property(_datamodel.CommentIndex_id_get, _datamodel.CommentIndex_id_set, doc=r"""id : std::string""")
    __swig_destroy__ = _datamodel.delete_CommentIndex

# Register CommentIndex in _datamodel:
_datamodel.CommentIndex_swigregister(CommentIndex)

class Comment(Object):
    r"""Proxy of C++ Seiscomp::DataModel::Comment 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 _datamodel.Comment_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Comment_TypeInfo()

    def className(self):
        r"""className(Comment self) -> char const *"""
        return _datamodel.Comment_className(self)

    def typeInfo(self):
        r"""typeInfo(Comment self) -> RTTI"""
        return _datamodel.Comment_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Comment
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Comment
        """
        return _datamodel.Comment_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Comment
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Comment
        """
        return _datamodel.Comment_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Comment self, GenericArchive ar)"""
        return _datamodel.Comment_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Comment_Meta()

    def meta(self):
        r"""meta(Comment self) -> MetaObject"""
        return _datamodel.Comment_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Comment self) -> Comment
        __init__(Comment self, Comment other) -> Comment
        """
        _datamodel.Comment_swiginit(self, _datamodel.new_Comment(*args))
    __swig_destroy__ = _datamodel.delete_Comment

    def __eq__(self, other):
        r"""__eq__(Comment self, Comment other) -> bool"""
        return _datamodel.Comment___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Comment self, Comment other) -> bool"""
        return _datamodel.Comment___ne__(self, other)

    def equal(self, other):
        r"""equal(Comment self, Comment other) -> bool"""
        return _datamodel.Comment_equal(self, other)

    def setText(self, text):
        r"""setText(Comment self, std::string const & text)"""
        return _datamodel.Comment_setText(self, text)

    def text(self):
        r"""text(Comment self) -> std::string const &"""
        return _datamodel.Comment_text(self)

    def setId(self, id):
        r"""setId(Comment self, std::string const & id)"""
        return _datamodel.Comment_setId(self, id)

    def id(self):
        r"""id(Comment self) -> std::string const &"""
        return _datamodel.Comment_id(self)

    def setStart(self, start):
        r"""setStart(Comment self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & start)"""
        return _datamodel.Comment_setStart(self, start)

    def start(self):
        r"""start(Comment self) -> Time"""
        return _datamodel.Comment_start(self)

    def setEnd(self, end):
        r"""setEnd(Comment self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.Comment_setEnd(self, end)

    def end(self):
        r"""end(Comment self) -> Time"""
        return _datamodel.Comment_end(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(Comment self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.Comment_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(Comment self) -> CreationInfo
        creationInfo(Comment self) -> CreationInfo
        """
        return _datamodel.Comment_creationInfo(self, *args)

    def index(self):
        r"""index(Comment self) -> CommentIndex"""
        return _datamodel.Comment_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Comment self, Comment lhs) -> bool"""
        return _datamodel.Comment_equalIndex(self, lhs)

    def momentTensor(self):
        r"""momentTensor(Comment self) -> MomentTensor"""
        return _datamodel.Comment_momentTensor(self)

    def focalMechanism(self):
        r"""focalMechanism(Comment self) -> FocalMechanism"""
        return _datamodel.Comment_focalMechanism(self)

    def amplitude(self):
        r"""amplitude(Comment self) -> Amplitude"""
        return _datamodel.Comment_amplitude(self)

    def magnitude(self):
        r"""magnitude(Comment self) -> Magnitude"""
        return _datamodel.Comment_magnitude(self)

    def stationMagnitude(self):
        r"""stationMagnitude(Comment self) -> StationMagnitude"""
        return _datamodel.Comment_stationMagnitude(self)

    def pick(self):
        r"""pick(Comment self) -> Pick"""
        return _datamodel.Comment_pick(self)

    def event(self):
        r"""event(Comment self) -> Event"""
        return _datamodel.Comment_event(self)

    def origin(self):
        r"""origin(Comment self) -> Origin"""
        return _datamodel.Comment_origin(self)

    def parameter(self):
        r"""parameter(Comment self) -> Parameter"""
        return _datamodel.Comment_parameter(self)

    def parameterSet(self):
        r"""parameterSet(Comment self) -> ParameterSet"""
        return _datamodel.Comment_parameterSet(self)

    def stream(self):
        r"""stream(Comment self) -> Stream"""
        return _datamodel.Comment_stream(self)

    def sensorLocation(self):
        r"""sensorLocation(Comment self) -> SensorLocation"""
        return _datamodel.Comment_sensorLocation(self)

    def station(self):
        r"""station(Comment self) -> Station"""
        return _datamodel.Comment_station(self)

    def network(self):
        r"""network(Comment self) -> Network"""
        return _datamodel.Comment_network(self)

    def assign(self, other):
        r"""assign(Comment self, Object other) -> bool"""
        return _datamodel.Comment_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Comment self, PublicObject parent) -> bool"""
        return _datamodel.Comment_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Comment self, PublicObject parent) -> bool"""
        return _datamodel.Comment_detachFrom(self, parent)

    def detach(self):
        r"""detach(Comment self) -> bool"""
        return _datamodel.Comment_detach(self)

    def clone(self):
        r"""clone(Comment self) -> Object"""
        return _datamodel.Comment_clone(self)

    def accept(self, visitor):
        r"""accept(Comment self, Visitor visitor)"""
        return _datamodel.Comment_accept(self, visitor)

# Register Comment in _datamodel:
_datamodel.Comment_swigregister(Comment)

def Comment_ClassName():
    r"""Comment_ClassName() -> char const *"""
    return _datamodel.Comment_ClassName()

def Comment_TypeInfo():
    r"""Comment_TypeInfo() -> RTTI"""
    return _datamodel.Comment_TypeInfo()

def Comment_Cast(*args):
    r"""
    Comment_Cast(BaseObject o) -> Comment
    Comment_Cast(Seiscomp::Core::BaseObjectPtr o) -> Comment
    """
    return _datamodel.Comment_Cast(*args)

def Comment_ConstCast(*args):
    r"""
    Comment_ConstCast(BaseObject o) -> Comment
    Comment_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Comment
    """
    return _datamodel.Comment_ConstCast(*args)

def Comment_Meta():
    r"""Comment_Meta() -> MetaObject"""
    return _datamodel.Comment_Meta()

class ComplexArray(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::ComplexArray 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 _datamodel.ComplexArray_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ComplexArray_TypeInfo()

    def className(self):
        r"""className(ComplexArray self) -> char const *"""
        return _datamodel.ComplexArray_className(self)

    def typeInfo(self):
        r"""typeInfo(ComplexArray self) -> RTTI"""
        return _datamodel.ComplexArray_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ComplexArray
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ComplexArray
        """
        return _datamodel.ComplexArray_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ComplexArray
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ComplexArray
        """
        return _datamodel.ComplexArray_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ComplexArray self, GenericArchive ar)"""
        return _datamodel.ComplexArray_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ComplexArray_Meta()

    def meta(self):
        r"""meta(ComplexArray self) -> MetaObject"""
        return _datamodel.ComplexArray_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ComplexArray self) -> ComplexArray
        __init__(ComplexArray self, ComplexArray other) -> ComplexArray
        """
        _datamodel.ComplexArray_swiginit(self, _datamodel.new_ComplexArray(*args))
    __swig_destroy__ = _datamodel.delete_ComplexArray

    def __eq__(self, other):
        r"""__eq__(ComplexArray self, ComplexArray other) -> bool"""
        return _datamodel.ComplexArray___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ComplexArray self, ComplexArray other) -> bool"""
        return _datamodel.ComplexArray___ne__(self, other)

    def equal(self, other):
        r"""equal(ComplexArray self, ComplexArray other) -> bool"""
        return _datamodel.ComplexArray_equal(self, other)

    def setContent(self, arg2):
        r"""setContent(ComplexArray self,  arg2)"""
        return _datamodel.ComplexArray_setContent(self, arg2)

    def content(self, *args):
        r"""
        content(ComplexArray self)
        content(ComplexArray self)
        """
        return _datamodel.ComplexArray_content(self, *args)

# Register ComplexArray in _datamodel:
_datamodel.ComplexArray_swigregister(ComplexArray)

def ComplexArray_ClassName():
    r"""ComplexArray_ClassName() -> char const *"""
    return _datamodel.ComplexArray_ClassName()

def ComplexArray_TypeInfo():
    r"""ComplexArray_TypeInfo() -> RTTI"""
    return _datamodel.ComplexArray_TypeInfo()

def ComplexArray_Cast(*args):
    r"""
    ComplexArray_Cast(BaseObject o) -> ComplexArray
    ComplexArray_Cast(Seiscomp::Core::BaseObjectPtr o) -> ComplexArray
    """
    return _datamodel.ComplexArray_Cast(*args)

def ComplexArray_ConstCast(*args):
    r"""
    ComplexArray_ConstCast(BaseObject o) -> ComplexArray
    ComplexArray_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ComplexArray
    """
    return _datamodel.ComplexArray_ConstCast(*args)

def ComplexArray_Meta():
    r"""ComplexArray_Meta() -> MetaObject"""
    return _datamodel.ComplexArray_Meta()

class RealPDF1D(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::RealPDF1D 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 _datamodel.RealPDF1D_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.RealPDF1D_TypeInfo()

    def className(self):
        r"""className(RealPDF1D self) -> char const *"""
        return _datamodel.RealPDF1D_className(self)

    def typeInfo(self):
        r"""typeInfo(RealPDF1D self) -> RTTI"""
        return _datamodel.RealPDF1D_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> RealPDF1D
        Cast(Seiscomp::Core::BaseObjectPtr o) -> RealPDF1D
        """
        return _datamodel.RealPDF1D_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> RealPDF1D
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealPDF1D
        """
        return _datamodel.RealPDF1D_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(RealPDF1D self, GenericArchive ar)"""
        return _datamodel.RealPDF1D_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.RealPDF1D_Meta()

    def meta(self):
        r"""meta(RealPDF1D self) -> MetaObject"""
        return _datamodel.RealPDF1D_meta(self)

    def __init__(self, *args):
        r"""
        __init__(RealPDF1D self) -> RealPDF1D
        __init__(RealPDF1D self, RealPDF1D other) -> RealPDF1D
        """
        _datamodel.RealPDF1D_swiginit(self, _datamodel.new_RealPDF1D(*args))
    __swig_destroy__ = _datamodel.delete_RealPDF1D

    def __eq__(self, other):
        r"""__eq__(RealPDF1D self, RealPDF1D other) -> bool"""
        return _datamodel.RealPDF1D___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(RealPDF1D self, RealPDF1D other) -> bool"""
        return _datamodel.RealPDF1D___ne__(self, other)

    def equal(self, other):
        r"""equal(RealPDF1D self, RealPDF1D other) -> bool"""
        return _datamodel.RealPDF1D_equal(self, other)

    def setVariable(self, variable):
        r"""setVariable(RealPDF1D self, RealArray variable)"""
        return _datamodel.RealPDF1D_setVariable(self, variable)

    def variable(self, *args):
        r"""
        variable(RealPDF1D self) -> RealArray
        variable(RealPDF1D self) -> RealArray
        """
        return _datamodel.RealPDF1D_variable(self, *args)

    def setProbability(self, probability):
        r"""setProbability(RealPDF1D self, RealArray probability)"""
        return _datamodel.RealPDF1D_setProbability(self, probability)

    def probability(self, *args):
        r"""
        probability(RealPDF1D self) -> RealArray
        probability(RealPDF1D self) -> RealArray
        """
        return _datamodel.RealPDF1D_probability(self, *args)

# Register RealPDF1D in _datamodel:
_datamodel.RealPDF1D_swigregister(RealPDF1D)

def RealPDF1D_ClassName():
    r"""RealPDF1D_ClassName() -> char const *"""
    return _datamodel.RealPDF1D_ClassName()

def RealPDF1D_TypeInfo():
    r"""RealPDF1D_TypeInfo() -> RTTI"""
    return _datamodel.RealPDF1D_TypeInfo()

def RealPDF1D_Cast(*args):
    r"""
    RealPDF1D_Cast(BaseObject o) -> RealPDF1D
    RealPDF1D_Cast(Seiscomp::Core::BaseObjectPtr o) -> RealPDF1D
    """
    return _datamodel.RealPDF1D_Cast(*args)

def RealPDF1D_ConstCast(*args):
    r"""
    RealPDF1D_ConstCast(BaseObject o) -> RealPDF1D
    RealPDF1D_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealPDF1D
    """
    return _datamodel.RealPDF1D_ConstCast(*args)

def RealPDF1D_Meta():
    r"""RealPDF1D_Meta() -> MetaObject"""
    return _datamodel.RealPDF1D_Meta()

class RealQuantity(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::RealQuantity 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 _datamodel.RealQuantity_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.RealQuantity_TypeInfo()

    def className(self):
        r"""className(RealQuantity self) -> char const *"""
        return _datamodel.RealQuantity_className(self)

    def typeInfo(self):
        r"""typeInfo(RealQuantity self) -> RTTI"""
        return _datamodel.RealQuantity_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> RealQuantity
        Cast(Seiscomp::Core::BaseObjectPtr o) -> RealQuantity
        """
        return _datamodel.RealQuantity_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> RealQuantity
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealQuantity
        """
        return _datamodel.RealQuantity_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(RealQuantity self, GenericArchive ar)"""
        return _datamodel.RealQuantity_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.RealQuantity_Meta()

    def meta(self):
        r"""meta(RealQuantity self) -> MetaObject"""
        return _datamodel.RealQuantity_meta(self)

    def __init__(self, *args):
        r"""
        __init__(RealQuantity self) -> RealQuantity
        __init__(RealQuantity self, RealQuantity other) -> RealQuantity
        __init__(RealQuantity self, double value, Seiscomp::Core::Optional< double >::Impl const & uncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel=Unset, Seiscomp::Core::Optional< Seiscomp::DataModel::RealPDF1D >::Impl const & pdf=Unset) -> RealQuantity
        """
        _datamodel.RealQuantity_swiginit(self, _datamodel.new_RealQuantity(*args))
    __swig_destroy__ = _datamodel.delete_RealQuantity

    def __eq__(self, other):
        r"""__eq__(RealQuantity self, RealQuantity other) -> bool"""
        return _datamodel.RealQuantity___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(RealQuantity self, RealQuantity other) -> bool"""
        return _datamodel.RealQuantity___ne__(self, other)

    def equal(self, other):
        r"""equal(RealQuantity self, RealQuantity other) -> bool"""
        return _datamodel.RealQuantity_equal(self, other)

    def setValue(self, value):
        r"""setValue(RealQuantity self, double value)"""
        return _datamodel.RealQuantity_setValue(self, value)

    def value(self):
        r"""value(RealQuantity self) -> double"""
        return _datamodel.RealQuantity_value(self)

    def setUncertainty(self, uncertainty):
        r"""setUncertainty(RealQuantity self, Seiscomp::Core::Optional< double >::Impl const & uncertainty)"""
        return _datamodel.RealQuantity_setUncertainty(self, uncertainty)

    def uncertainty(self):
        r"""uncertainty(RealQuantity self) -> double"""
        return _datamodel.RealQuantity_uncertainty(self)

    def setLowerUncertainty(self, lowerUncertainty):
        r"""setLowerUncertainty(RealQuantity self, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty)"""
        return _datamodel.RealQuantity_setLowerUncertainty(self, lowerUncertainty)

    def lowerUncertainty(self):
        r"""lowerUncertainty(RealQuantity self) -> double"""
        return _datamodel.RealQuantity_lowerUncertainty(self)

    def setUpperUncertainty(self, upperUncertainty):
        r"""setUpperUncertainty(RealQuantity self, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty)"""
        return _datamodel.RealQuantity_setUpperUncertainty(self, upperUncertainty)

    def upperUncertainty(self):
        r"""upperUncertainty(RealQuantity self) -> double"""
        return _datamodel.RealQuantity_upperUncertainty(self)

    def setConfidenceLevel(self, confidenceLevel):
        r"""setConfidenceLevel(RealQuantity self, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel)"""
        return _datamodel.RealQuantity_setConfidenceLevel(self, confidenceLevel)

    def confidenceLevel(self):
        r"""confidenceLevel(RealQuantity self) -> double"""
        return _datamodel.RealQuantity_confidenceLevel(self)

    def setPdf(self, pdf):
        r"""setPdf(RealQuantity self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealPDF1D >::Impl const & pdf)"""
        return _datamodel.RealQuantity_setPdf(self, pdf)

    def pdf(self, *args):
        r"""
        pdf(RealQuantity self) -> RealPDF1D
        pdf(RealQuantity self) -> RealPDF1D
        """
        return _datamodel.RealQuantity_pdf(self, *args)

# Register RealQuantity in _datamodel:
_datamodel.RealQuantity_swigregister(RealQuantity)

def RealQuantity_ClassName():
    r"""RealQuantity_ClassName() -> char const *"""
    return _datamodel.RealQuantity_ClassName()

def RealQuantity_TypeInfo():
    r"""RealQuantity_TypeInfo() -> RTTI"""
    return _datamodel.RealQuantity_TypeInfo()

def RealQuantity_Cast(*args):
    r"""
    RealQuantity_Cast(BaseObject o) -> RealQuantity
    RealQuantity_Cast(Seiscomp::Core::BaseObjectPtr o) -> RealQuantity
    """
    return _datamodel.RealQuantity_Cast(*args)

def RealQuantity_ConstCast(*args):
    r"""
    RealQuantity_ConstCast(BaseObject o) -> RealQuantity
    RealQuantity_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealQuantity
    """
    return _datamodel.RealQuantity_ConstCast(*args)

def RealQuantity_Meta():
    r"""RealQuantity_Meta() -> MetaObject"""
    return _datamodel.RealQuantity_Meta()

class IntegerQuantity(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::IntegerQuantity 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 _datamodel.IntegerQuantity_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.IntegerQuantity_TypeInfo()

    def className(self):
        r"""className(IntegerQuantity self) -> char const *"""
        return _datamodel.IntegerQuantity_className(self)

    def typeInfo(self):
        r"""typeInfo(IntegerQuantity self) -> RTTI"""
        return _datamodel.IntegerQuantity_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> IntegerQuantity
        Cast(Seiscomp::Core::BaseObjectPtr o) -> IntegerQuantity
        """
        return _datamodel.IntegerQuantity_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> IntegerQuantity
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> IntegerQuantity
        """
        return _datamodel.IntegerQuantity_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(IntegerQuantity self, GenericArchive ar)"""
        return _datamodel.IntegerQuantity_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.IntegerQuantity_Meta()

    def meta(self):
        r"""meta(IntegerQuantity self) -> MetaObject"""
        return _datamodel.IntegerQuantity_meta(self)

    def __init__(self, *args):
        r"""
        __init__(IntegerQuantity self) -> IntegerQuantity
        __init__(IntegerQuantity self, IntegerQuantity other) -> IntegerQuantity
        __init__(IntegerQuantity self, int value, Seiscomp::Core::Optional< int >::Impl const & uncertainty=Unset, Seiscomp::Core::Optional< int >::Impl const & lowerUncertainty=Unset, Seiscomp::Core::Optional< int >::Impl const & upperUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel=Unset) -> IntegerQuantity
        """
        _datamodel.IntegerQuantity_swiginit(self, _datamodel.new_IntegerQuantity(*args))
    __swig_destroy__ = _datamodel.delete_IntegerQuantity

    def __eq__(self, other):
        r"""__eq__(IntegerQuantity self, IntegerQuantity other) -> bool"""
        return _datamodel.IntegerQuantity___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(IntegerQuantity self, IntegerQuantity other) -> bool"""
        return _datamodel.IntegerQuantity___ne__(self, other)

    def equal(self, other):
        r"""equal(IntegerQuantity self, IntegerQuantity other) -> bool"""
        return _datamodel.IntegerQuantity_equal(self, other)

    def setValue(self, value):
        r"""setValue(IntegerQuantity self, int value)"""
        return _datamodel.IntegerQuantity_setValue(self, value)

    def value(self):
        r"""value(IntegerQuantity self) -> int"""
        return _datamodel.IntegerQuantity_value(self)

    def setUncertainty(self, uncertainty):
        r"""setUncertainty(IntegerQuantity self, Seiscomp::Core::Optional< int >::Impl const & uncertainty)"""
        return _datamodel.IntegerQuantity_setUncertainty(self, uncertainty)

    def uncertainty(self):
        r"""uncertainty(IntegerQuantity self) -> int"""
        return _datamodel.IntegerQuantity_uncertainty(self)

    def setLowerUncertainty(self, lowerUncertainty):
        r"""setLowerUncertainty(IntegerQuantity self, Seiscomp::Core::Optional< int >::Impl const & lowerUncertainty)"""
        return _datamodel.IntegerQuantity_setLowerUncertainty(self, lowerUncertainty)

    def lowerUncertainty(self):
        r"""lowerUncertainty(IntegerQuantity self) -> int"""
        return _datamodel.IntegerQuantity_lowerUncertainty(self)

    def setUpperUncertainty(self, upperUncertainty):
        r"""setUpperUncertainty(IntegerQuantity self, Seiscomp::Core::Optional< int >::Impl const & upperUncertainty)"""
        return _datamodel.IntegerQuantity_setUpperUncertainty(self, upperUncertainty)

    def upperUncertainty(self):
        r"""upperUncertainty(IntegerQuantity self) -> int"""
        return _datamodel.IntegerQuantity_upperUncertainty(self)

    def setConfidenceLevel(self, confidenceLevel):
        r"""setConfidenceLevel(IntegerQuantity self, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel)"""
        return _datamodel.IntegerQuantity_setConfidenceLevel(self, confidenceLevel)

    def confidenceLevel(self):
        r"""confidenceLevel(IntegerQuantity self) -> double"""
        return _datamodel.IntegerQuantity_confidenceLevel(self)

# Register IntegerQuantity in _datamodel:
_datamodel.IntegerQuantity_swigregister(IntegerQuantity)

def IntegerQuantity_ClassName():
    r"""IntegerQuantity_ClassName() -> char const *"""
    return _datamodel.IntegerQuantity_ClassName()

def IntegerQuantity_TypeInfo():
    r"""IntegerQuantity_TypeInfo() -> RTTI"""
    return _datamodel.IntegerQuantity_TypeInfo()

def IntegerQuantity_Cast(*args):
    r"""
    IntegerQuantity_Cast(BaseObject o) -> IntegerQuantity
    IntegerQuantity_Cast(Seiscomp::Core::BaseObjectPtr o) -> IntegerQuantity
    """
    return _datamodel.IntegerQuantity_Cast(*args)

def IntegerQuantity_ConstCast(*args):
    r"""
    IntegerQuantity_ConstCast(BaseObject o) -> IntegerQuantity
    IntegerQuantity_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> IntegerQuantity
    """
    return _datamodel.IntegerQuantity_ConstCast(*args)

def IntegerQuantity_Meta():
    r"""IntegerQuantity_Meta() -> MetaObject"""
    return _datamodel.IntegerQuantity_Meta()

class Axis(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::Axis 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 _datamodel.Axis_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Axis_TypeInfo()

    def className(self):
        r"""className(Axis self) -> char const *"""
        return _datamodel.Axis_className(self)

    def typeInfo(self):
        r"""typeInfo(Axis self) -> RTTI"""
        return _datamodel.Axis_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Axis
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Axis
        """
        return _datamodel.Axis_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Axis
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Axis
        """
        return _datamodel.Axis_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Axis self, GenericArchive ar)"""
        return _datamodel.Axis_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Axis_Meta()

    def meta(self):
        r"""meta(Axis self) -> MetaObject"""
        return _datamodel.Axis_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Axis self) -> Axis
        __init__(Axis self, Axis other) -> Axis
        """
        _datamodel.Axis_swiginit(self, _datamodel.new_Axis(*args))
    __swig_destroy__ = _datamodel.delete_Axis

    def __eq__(self, other):
        r"""__eq__(Axis self, Axis other) -> bool"""
        return _datamodel.Axis___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Axis self, Axis other) -> bool"""
        return _datamodel.Axis___ne__(self, other)

    def equal(self, other):
        r"""equal(Axis self, Axis other) -> bool"""
        return _datamodel.Axis_equal(self, other)

    def setAzimuth(self, azimuth):
        r"""setAzimuth(Axis self, RealQuantity azimuth)"""
        return _datamodel.Axis_setAzimuth(self, azimuth)

    def azimuth(self, *args):
        r"""
        azimuth(Axis self) -> RealQuantity
        azimuth(Axis self) -> RealQuantity
        """
        return _datamodel.Axis_azimuth(self, *args)

    def setPlunge(self, plunge):
        r"""setPlunge(Axis self, RealQuantity plunge)"""
        return _datamodel.Axis_setPlunge(self, plunge)

    def plunge(self, *args):
        r"""
        plunge(Axis self) -> RealQuantity
        plunge(Axis self) -> RealQuantity
        """
        return _datamodel.Axis_plunge(self, *args)

    def setLength(self, length):
        r"""setLength(Axis self, RealQuantity length)"""
        return _datamodel.Axis_setLength(self, length)

    def length(self, *args):
        r"""
        length(Axis self) -> RealQuantity
        length(Axis self) -> RealQuantity
        """
        return _datamodel.Axis_length(self, *args)

# Register Axis in _datamodel:
_datamodel.Axis_swigregister(Axis)

def Axis_ClassName():
    r"""Axis_ClassName() -> char const *"""
    return _datamodel.Axis_ClassName()

def Axis_TypeInfo():
    r"""Axis_TypeInfo() -> RTTI"""
    return _datamodel.Axis_TypeInfo()

def Axis_Cast(*args):
    r"""
    Axis_Cast(BaseObject o) -> Axis
    Axis_Cast(Seiscomp::Core::BaseObjectPtr o) -> Axis
    """
    return _datamodel.Axis_Cast(*args)

def Axis_ConstCast(*args):
    r"""
    Axis_ConstCast(BaseObject o) -> Axis
    Axis_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Axis
    """
    return _datamodel.Axis_ConstCast(*args)

def Axis_Meta():
    r"""Axis_Meta() -> MetaObject"""
    return _datamodel.Axis_Meta()

class PrincipalAxes(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::PrincipalAxes 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 _datamodel.PrincipalAxes_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.PrincipalAxes_TypeInfo()

    def className(self):
        r"""className(PrincipalAxes self) -> char const *"""
        return _datamodel.PrincipalAxes_className(self)

    def typeInfo(self):
        r"""typeInfo(PrincipalAxes self) -> RTTI"""
        return _datamodel.PrincipalAxes_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> PrincipalAxes
        Cast(Seiscomp::Core::BaseObjectPtr o) -> PrincipalAxes
        """
        return _datamodel.PrincipalAxes_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> PrincipalAxes
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PrincipalAxes
        """
        return _datamodel.PrincipalAxes_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(PrincipalAxes self, GenericArchive ar)"""
        return _datamodel.PrincipalAxes_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.PrincipalAxes_Meta()

    def meta(self):
        r"""meta(PrincipalAxes self) -> MetaObject"""
        return _datamodel.PrincipalAxes_meta(self)

    def __init__(self, *args):
        r"""
        __init__(PrincipalAxes self) -> PrincipalAxes
        __init__(PrincipalAxes self, PrincipalAxes other) -> PrincipalAxes
        """
        _datamodel.PrincipalAxes_swiginit(self, _datamodel.new_PrincipalAxes(*args))
    __swig_destroy__ = _datamodel.delete_PrincipalAxes

    def __eq__(self, other):
        r"""__eq__(PrincipalAxes self, PrincipalAxes other) -> bool"""
        return _datamodel.PrincipalAxes___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(PrincipalAxes self, PrincipalAxes other) -> bool"""
        return _datamodel.PrincipalAxes___ne__(self, other)

    def equal(self, other):
        r"""equal(PrincipalAxes self, PrincipalAxes other) -> bool"""
        return _datamodel.PrincipalAxes_equal(self, other)

    def setTAxis(self, tAxis):
        r"""setTAxis(PrincipalAxes self, Axis tAxis)"""
        return _datamodel.PrincipalAxes_setTAxis(self, tAxis)

    def tAxis(self, *args):
        r"""
        tAxis(PrincipalAxes self) -> Axis
        tAxis(PrincipalAxes self) -> Axis
        """
        return _datamodel.PrincipalAxes_tAxis(self, *args)

    def setPAxis(self, pAxis):
        r"""setPAxis(PrincipalAxes self, Axis pAxis)"""
        return _datamodel.PrincipalAxes_setPAxis(self, pAxis)

    def pAxis(self, *args):
        r"""
        pAxis(PrincipalAxes self) -> Axis
        pAxis(PrincipalAxes self) -> Axis
        """
        return _datamodel.PrincipalAxes_pAxis(self, *args)

    def setNAxis(self, nAxis):
        r"""setNAxis(PrincipalAxes self, Seiscomp::Core::Optional< Seiscomp::DataModel::Axis >::Impl const & nAxis)"""
        return _datamodel.PrincipalAxes_setNAxis(self, nAxis)

    def nAxis(self, *args):
        r"""
        nAxis(PrincipalAxes self) -> Axis
        nAxis(PrincipalAxes self) -> Axis
        """
        return _datamodel.PrincipalAxes_nAxis(self, *args)

# Register PrincipalAxes in _datamodel:
_datamodel.PrincipalAxes_swigregister(PrincipalAxes)

def PrincipalAxes_ClassName():
    r"""PrincipalAxes_ClassName() -> char const *"""
    return _datamodel.PrincipalAxes_ClassName()

def PrincipalAxes_TypeInfo():
    r"""PrincipalAxes_TypeInfo() -> RTTI"""
    return _datamodel.PrincipalAxes_TypeInfo()

def PrincipalAxes_Cast(*args):
    r"""
    PrincipalAxes_Cast(BaseObject o) -> PrincipalAxes
    PrincipalAxes_Cast(Seiscomp::Core::BaseObjectPtr o) -> PrincipalAxes
    """
    return _datamodel.PrincipalAxes_Cast(*args)

def PrincipalAxes_ConstCast(*args):
    r"""
    PrincipalAxes_ConstCast(BaseObject o) -> PrincipalAxes
    PrincipalAxes_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PrincipalAxes
    """
    return _datamodel.PrincipalAxes_ConstCast(*args)

def PrincipalAxes_Meta():
    r"""PrincipalAxes_Meta() -> MetaObject"""
    return _datamodel.PrincipalAxes_Meta()

class Tensor(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::Tensor 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 _datamodel.Tensor_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Tensor_TypeInfo()

    def className(self):
        r"""className(Tensor self) -> char const *"""
        return _datamodel.Tensor_className(self)

    def typeInfo(self):
        r"""typeInfo(Tensor self) -> RTTI"""
        return _datamodel.Tensor_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Tensor
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Tensor
        """
        return _datamodel.Tensor_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Tensor
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Tensor
        """
        return _datamodel.Tensor_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Tensor self, GenericArchive ar)"""
        return _datamodel.Tensor_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Tensor_Meta()

    def meta(self):
        r"""meta(Tensor self) -> MetaObject"""
        return _datamodel.Tensor_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Tensor self) -> Tensor
        __init__(Tensor self, Tensor other) -> Tensor
        """
        _datamodel.Tensor_swiginit(self, _datamodel.new_Tensor(*args))
    __swig_destroy__ = _datamodel.delete_Tensor

    def __eq__(self, other):
        r"""__eq__(Tensor self, Tensor other) -> bool"""
        return _datamodel.Tensor___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Tensor self, Tensor other) -> bool"""
        return _datamodel.Tensor___ne__(self, other)

    def equal(self, other):
        r"""equal(Tensor self, Tensor other) -> bool"""
        return _datamodel.Tensor_equal(self, other)

    def setMrr(self, Mrr):
        r"""setMrr(Tensor self, RealQuantity Mrr)"""
        return _datamodel.Tensor_setMrr(self, Mrr)

    def Mrr(self, *args):
        r"""
        Mrr(Tensor self) -> RealQuantity
        Mrr(Tensor self) -> RealQuantity
        """
        return _datamodel.Tensor_Mrr(self, *args)

    def setMtt(self, Mtt):
        r"""setMtt(Tensor self, RealQuantity Mtt)"""
        return _datamodel.Tensor_setMtt(self, Mtt)

    def Mtt(self, *args):
        r"""
        Mtt(Tensor self) -> RealQuantity
        Mtt(Tensor self) -> RealQuantity
        """
        return _datamodel.Tensor_Mtt(self, *args)

    def setMpp(self, Mpp):
        r"""setMpp(Tensor self, RealQuantity Mpp)"""
        return _datamodel.Tensor_setMpp(self, Mpp)

    def Mpp(self, *args):
        r"""
        Mpp(Tensor self) -> RealQuantity
        Mpp(Tensor self) -> RealQuantity
        """
        return _datamodel.Tensor_Mpp(self, *args)

    def setMrt(self, Mrt):
        r"""setMrt(Tensor self, RealQuantity Mrt)"""
        return _datamodel.Tensor_setMrt(self, Mrt)

    def Mrt(self, *args):
        r"""
        Mrt(Tensor self) -> RealQuantity
        Mrt(Tensor self) -> RealQuantity
        """
        return _datamodel.Tensor_Mrt(self, *args)

    def setMrp(self, Mrp):
        r"""setMrp(Tensor self, RealQuantity Mrp)"""
        return _datamodel.Tensor_setMrp(self, Mrp)

    def Mrp(self, *args):
        r"""
        Mrp(Tensor self) -> RealQuantity
        Mrp(Tensor self) -> RealQuantity
        """
        return _datamodel.Tensor_Mrp(self, *args)

    def setMtp(self, Mtp):
        r"""setMtp(Tensor self, RealQuantity Mtp)"""
        return _datamodel.Tensor_setMtp(self, Mtp)

    def Mtp(self, *args):
        r"""
        Mtp(Tensor self) -> RealQuantity
        Mtp(Tensor self) -> RealQuantity
        """
        return _datamodel.Tensor_Mtp(self, *args)

# Register Tensor in _datamodel:
_datamodel.Tensor_swigregister(Tensor)

def Tensor_ClassName():
    r"""Tensor_ClassName() -> char const *"""
    return _datamodel.Tensor_ClassName()

def Tensor_TypeInfo():
    r"""Tensor_TypeInfo() -> RTTI"""
    return _datamodel.Tensor_TypeInfo()

def Tensor_Cast(*args):
    r"""
    Tensor_Cast(BaseObject o) -> Tensor
    Tensor_Cast(Seiscomp::Core::BaseObjectPtr o) -> Tensor
    """
    return _datamodel.Tensor_Cast(*args)

def Tensor_ConstCast(*args):
    r"""
    Tensor_ConstCast(BaseObject o) -> Tensor
    Tensor_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Tensor
    """
    return _datamodel.Tensor_ConstCast(*args)

def Tensor_Meta():
    r"""Tensor_Meta() -> MetaObject"""
    return _datamodel.Tensor_Meta()

class OriginQuality(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::OriginQuality 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 _datamodel.OriginQuality_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.OriginQuality_TypeInfo()

    def className(self):
        r"""className(OriginQuality self) -> char const *"""
        return _datamodel.OriginQuality_className(self)

    def typeInfo(self):
        r"""typeInfo(OriginQuality self) -> RTTI"""
        return _datamodel.OriginQuality_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> OriginQuality
        Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginQuality
        """
        return _datamodel.OriginQuality_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> OriginQuality
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginQuality
        """
        return _datamodel.OriginQuality_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(OriginQuality self, GenericArchive ar)"""
        return _datamodel.OriginQuality_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.OriginQuality_Meta()

    def meta(self):
        r"""meta(OriginQuality self) -> MetaObject"""
        return _datamodel.OriginQuality_meta(self)

    def __init__(self, *args):
        r"""
        __init__(OriginQuality self) -> OriginQuality
        __init__(OriginQuality self, OriginQuality other) -> OriginQuality
        """
        _datamodel.OriginQuality_swiginit(self, _datamodel.new_OriginQuality(*args))
    __swig_destroy__ = _datamodel.delete_OriginQuality

    def __eq__(self, other):
        r"""__eq__(OriginQuality self, OriginQuality other) -> bool"""
        return _datamodel.OriginQuality___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(OriginQuality self, OriginQuality other) -> bool"""
        return _datamodel.OriginQuality___ne__(self, other)

    def equal(self, other):
        r"""equal(OriginQuality self, OriginQuality other) -> bool"""
        return _datamodel.OriginQuality_equal(self, other)

    def setAssociatedPhaseCount(self, associatedPhaseCount):
        r"""setAssociatedPhaseCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & associatedPhaseCount)"""
        return _datamodel.OriginQuality_setAssociatedPhaseCount(self, associatedPhaseCount)

    def associatedPhaseCount(self):
        r"""associatedPhaseCount(OriginQuality self) -> int"""
        return _datamodel.OriginQuality_associatedPhaseCount(self)

    def setUsedPhaseCount(self, usedPhaseCount):
        r"""setUsedPhaseCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & usedPhaseCount)"""
        return _datamodel.OriginQuality_setUsedPhaseCount(self, usedPhaseCount)

    def usedPhaseCount(self):
        r"""usedPhaseCount(OriginQuality self) -> int"""
        return _datamodel.OriginQuality_usedPhaseCount(self)

    def setAssociatedStationCount(self, associatedStationCount):
        r"""setAssociatedStationCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & associatedStationCount)"""
        return _datamodel.OriginQuality_setAssociatedStationCount(self, associatedStationCount)

    def associatedStationCount(self):
        r"""associatedStationCount(OriginQuality self) -> int"""
        return _datamodel.OriginQuality_associatedStationCount(self)

    def setUsedStationCount(self, usedStationCount):
        r"""setUsedStationCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & usedStationCount)"""
        return _datamodel.OriginQuality_setUsedStationCount(self, usedStationCount)

    def usedStationCount(self):
        r"""usedStationCount(OriginQuality self) -> int"""
        return _datamodel.OriginQuality_usedStationCount(self)

    def setDepthPhaseCount(self, depthPhaseCount):
        r"""setDepthPhaseCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & depthPhaseCount)"""
        return _datamodel.OriginQuality_setDepthPhaseCount(self, depthPhaseCount)

    def depthPhaseCount(self):
        r"""depthPhaseCount(OriginQuality self) -> int"""
        return _datamodel.OriginQuality_depthPhaseCount(self)

    def setStandardError(self, standardError):
        r"""setStandardError(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & standardError)"""
        return _datamodel.OriginQuality_setStandardError(self, standardError)

    def standardError(self):
        r"""standardError(OriginQuality self) -> double"""
        return _datamodel.OriginQuality_standardError(self)

    def setAzimuthalGap(self, azimuthalGap):
        r"""setAzimuthalGap(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & azimuthalGap)"""
        return _datamodel.OriginQuality_setAzimuthalGap(self, azimuthalGap)

    def azimuthalGap(self):
        r"""azimuthalGap(OriginQuality self) -> double"""
        return _datamodel.OriginQuality_azimuthalGap(self)

    def setSecondaryAzimuthalGap(self, secondaryAzimuthalGap):
        r"""setSecondaryAzimuthalGap(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & secondaryAzimuthalGap)"""
        return _datamodel.OriginQuality_setSecondaryAzimuthalGap(self, secondaryAzimuthalGap)

    def secondaryAzimuthalGap(self):
        r"""secondaryAzimuthalGap(OriginQuality self) -> double"""
        return _datamodel.OriginQuality_secondaryAzimuthalGap(self)

    def setGroundTruthLevel(self, groundTruthLevel):
        r"""setGroundTruthLevel(OriginQuality self, std::string const & groundTruthLevel)"""
        return _datamodel.OriginQuality_setGroundTruthLevel(self, groundTruthLevel)

    def groundTruthLevel(self):
        r"""groundTruthLevel(OriginQuality self) -> std::string const &"""
        return _datamodel.OriginQuality_groundTruthLevel(self)

    def setMaximumDistance(self, maximumDistance):
        r"""setMaximumDistance(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & maximumDistance)"""
        return _datamodel.OriginQuality_setMaximumDistance(self, maximumDistance)

    def maximumDistance(self):
        r"""maximumDistance(OriginQuality self) -> double"""
        return _datamodel.OriginQuality_maximumDistance(self)

    def setMinimumDistance(self, minimumDistance):
        r"""setMinimumDistance(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & minimumDistance)"""
        return _datamodel.OriginQuality_setMinimumDistance(self, minimumDistance)

    def minimumDistance(self):
        r"""minimumDistance(OriginQuality self) -> double"""
        return _datamodel.OriginQuality_minimumDistance(self)

    def setMedianDistance(self, medianDistance):
        r"""setMedianDistance(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & medianDistance)"""
        return _datamodel.OriginQuality_setMedianDistance(self, medianDistance)

    def medianDistance(self):
        r"""medianDistance(OriginQuality self) -> double"""
        return _datamodel.OriginQuality_medianDistance(self)

# Register OriginQuality in _datamodel:
_datamodel.OriginQuality_swigregister(OriginQuality)

def OriginQuality_ClassName():
    r"""OriginQuality_ClassName() -> char const *"""
    return _datamodel.OriginQuality_ClassName()

def OriginQuality_TypeInfo():
    r"""OriginQuality_TypeInfo() -> RTTI"""
    return _datamodel.OriginQuality_TypeInfo()

def OriginQuality_Cast(*args):
    r"""
    OriginQuality_Cast(BaseObject o) -> OriginQuality
    OriginQuality_Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginQuality
    """
    return _datamodel.OriginQuality_Cast(*args)

def OriginQuality_ConstCast(*args):
    r"""
    OriginQuality_ConstCast(BaseObject o) -> OriginQuality
    OriginQuality_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginQuality
    """
    return _datamodel.OriginQuality_ConstCast(*args)

def OriginQuality_Meta():
    r"""OriginQuality_Meta() -> MetaObject"""
    return _datamodel.OriginQuality_Meta()

class NodalPlane(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::NodalPlane 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 _datamodel.NodalPlane_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.NodalPlane_TypeInfo()

    def className(self):
        r"""className(NodalPlane self) -> char const *"""
        return _datamodel.NodalPlane_className(self)

    def typeInfo(self):
        r"""typeInfo(NodalPlane self) -> RTTI"""
        return _datamodel.NodalPlane_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> NodalPlane
        Cast(Seiscomp::Core::BaseObjectPtr o) -> NodalPlane
        """
        return _datamodel.NodalPlane_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> NodalPlane
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NodalPlane
        """
        return _datamodel.NodalPlane_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(NodalPlane self, GenericArchive ar)"""
        return _datamodel.NodalPlane_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.NodalPlane_Meta()

    def meta(self):
        r"""meta(NodalPlane self) -> MetaObject"""
        return _datamodel.NodalPlane_meta(self)

    def __init__(self, *args):
        r"""
        __init__(NodalPlane self) -> NodalPlane
        __init__(NodalPlane self, NodalPlane other) -> NodalPlane
        """
        _datamodel.NodalPlane_swiginit(self, _datamodel.new_NodalPlane(*args))
    __swig_destroy__ = _datamodel.delete_NodalPlane

    def __eq__(self, other):
        r"""__eq__(NodalPlane self, NodalPlane other) -> bool"""
        return _datamodel.NodalPlane___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(NodalPlane self, NodalPlane other) -> bool"""
        return _datamodel.NodalPlane___ne__(self, other)

    def equal(self, other):
        r"""equal(NodalPlane self, NodalPlane other) -> bool"""
        return _datamodel.NodalPlane_equal(self, other)

    def setStrike(self, strike):
        r"""setStrike(NodalPlane self, RealQuantity strike)"""
        return _datamodel.NodalPlane_setStrike(self, strike)

    def strike(self, *args):
        r"""
        strike(NodalPlane self) -> RealQuantity
        strike(NodalPlane self) -> RealQuantity
        """
        return _datamodel.NodalPlane_strike(self, *args)

    def setDip(self, dip):
        r"""setDip(NodalPlane self, RealQuantity dip)"""
        return _datamodel.NodalPlane_setDip(self, dip)

    def dip(self, *args):
        r"""
        dip(NodalPlane self) -> RealQuantity
        dip(NodalPlane self) -> RealQuantity
        """
        return _datamodel.NodalPlane_dip(self, *args)

    def setRake(self, rake):
        r"""setRake(NodalPlane self, RealQuantity rake)"""
        return _datamodel.NodalPlane_setRake(self, rake)

    def rake(self, *args):
        r"""
        rake(NodalPlane self) -> RealQuantity
        rake(NodalPlane self) -> RealQuantity
        """
        return _datamodel.NodalPlane_rake(self, *args)

# Register NodalPlane in _datamodel:
_datamodel.NodalPlane_swigregister(NodalPlane)

def NodalPlane_ClassName():
    r"""NodalPlane_ClassName() -> char const *"""
    return _datamodel.NodalPlane_ClassName()

def NodalPlane_TypeInfo():
    r"""NodalPlane_TypeInfo() -> RTTI"""
    return _datamodel.NodalPlane_TypeInfo()

def NodalPlane_Cast(*args):
    r"""
    NodalPlane_Cast(BaseObject o) -> NodalPlane
    NodalPlane_Cast(Seiscomp::Core::BaseObjectPtr o) -> NodalPlane
    """
    return _datamodel.NodalPlane_Cast(*args)

def NodalPlane_ConstCast(*args):
    r"""
    NodalPlane_ConstCast(BaseObject o) -> NodalPlane
    NodalPlane_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NodalPlane
    """
    return _datamodel.NodalPlane_ConstCast(*args)

def NodalPlane_Meta():
    r"""NodalPlane_Meta() -> MetaObject"""
    return _datamodel.NodalPlane_Meta()

class TimeWindow(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::TimeWindow 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 _datamodel.TimeWindow_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.TimeWindow_TypeInfo()

    def className(self):
        r"""className(TimeWindow self) -> char const *"""
        return _datamodel.TimeWindow_className(self)

    def typeInfo(self):
        r"""typeInfo(TimeWindow self) -> RTTI"""
        return _datamodel.TimeWindow_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> TimeWindow
        Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeWindow
        """
        return _datamodel.TimeWindow_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> TimeWindow
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeWindow
        """
        return _datamodel.TimeWindow_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(TimeWindow self, GenericArchive ar)"""
        return _datamodel.TimeWindow_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.TimeWindow_Meta()

    def meta(self):
        r"""meta(TimeWindow self) -> MetaObject"""
        return _datamodel.TimeWindow_meta(self)

    def __init__(self, *args):
        r"""
        __init__(TimeWindow self) -> TimeWindow
        __init__(TimeWindow self, TimeWindow other) -> TimeWindow
        __init__(TimeWindow self, Time reference) -> TimeWindow
        __init__(TimeWindow self, Time reference, double begin, double end) -> TimeWindow
        """
        _datamodel.TimeWindow_swiginit(self, _datamodel.new_TimeWindow(*args))
    __swig_destroy__ = _datamodel.delete_TimeWindow

    def __eq__(self, other):
        r"""__eq__(TimeWindow self, TimeWindow other) -> bool"""
        return _datamodel.TimeWindow___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(TimeWindow self, TimeWindow other) -> bool"""
        return _datamodel.TimeWindow___ne__(self, other)

    def equal(self, other):
        r"""equal(TimeWindow self, TimeWindow other) -> bool"""
        return _datamodel.TimeWindow_equal(self, other)

    def setReference(self, reference):
        r"""setReference(TimeWindow self, Time reference)"""
        return _datamodel.TimeWindow_setReference(self, reference)

    def reference(self):
        r"""reference(TimeWindow self) -> Time"""
        return _datamodel.TimeWindow_reference(self)

    def setBegin(self, begin):
        r"""setBegin(TimeWindow self, double begin)"""
        return _datamodel.TimeWindow_setBegin(self, begin)

    def begin(self):
        r"""begin(TimeWindow self) -> double"""
        return _datamodel.TimeWindow_begin(self)

    def setEnd(self, end):
        r"""setEnd(TimeWindow self, double end)"""
        return _datamodel.TimeWindow_setEnd(self, end)

    def end(self):
        r"""end(TimeWindow self) -> double"""
        return _datamodel.TimeWindow_end(self)

# Register TimeWindow in _datamodel:
_datamodel.TimeWindow_swigregister(TimeWindow)

def TimeWindow_ClassName():
    r"""TimeWindow_ClassName() -> char const *"""
    return _datamodel.TimeWindow_ClassName()

def TimeWindow_TypeInfo():
    r"""TimeWindow_TypeInfo() -> RTTI"""
    return _datamodel.TimeWindow_TypeInfo()

def TimeWindow_Cast(*args):
    r"""
    TimeWindow_Cast(BaseObject o) -> TimeWindow
    TimeWindow_Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeWindow
    """
    return _datamodel.TimeWindow_Cast(*args)

def TimeWindow_ConstCast(*args):
    r"""
    TimeWindow_ConstCast(BaseObject o) -> TimeWindow
    TimeWindow_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeWindow
    """
    return _datamodel.TimeWindow_ConstCast(*args)

def TimeWindow_Meta():
    r"""TimeWindow_Meta() -> MetaObject"""
    return _datamodel.TimeWindow_Meta()

class WaveformStreamID(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::WaveformStreamID 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 _datamodel.WaveformStreamID_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.WaveformStreamID_TypeInfo()

    def className(self):
        r"""className(WaveformStreamID self) -> char const *"""
        return _datamodel.WaveformStreamID_className(self)

    def typeInfo(self):
        r"""typeInfo(WaveformStreamID self) -> RTTI"""
        return _datamodel.WaveformStreamID_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> WaveformStreamID
        Cast(Seiscomp::Core::BaseObjectPtr o) -> WaveformStreamID
        """
        return _datamodel.WaveformStreamID_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> WaveformStreamID
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> WaveformStreamID
        """
        return _datamodel.WaveformStreamID_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(WaveformStreamID self, GenericArchive ar)"""
        return _datamodel.WaveformStreamID_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.WaveformStreamID_Meta()

    def meta(self):
        r"""meta(WaveformStreamID self) -> MetaObject"""
        return _datamodel.WaveformStreamID_meta(self)

    def __init__(self, *args):
        r"""
        __init__(WaveformStreamID self) -> WaveformStreamID
        __init__(WaveformStreamID self, WaveformStreamID other) -> WaveformStreamID
        __init__(WaveformStreamID self, std::string const & resourceURI) -> WaveformStreamID
        __init__(WaveformStreamID self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, std::string const & resourceURI) -> WaveformStreamID
        """
        _datamodel.WaveformStreamID_swiginit(self, _datamodel.new_WaveformStreamID(*args))
    __swig_destroy__ = _datamodel.delete_WaveformStreamID

    def __eq__(self, other):
        r"""__eq__(WaveformStreamID self, WaveformStreamID other) -> bool"""
        return _datamodel.WaveformStreamID___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(WaveformStreamID self, WaveformStreamID other) -> bool"""
        return _datamodel.WaveformStreamID___ne__(self, other)

    def equal(self, other):
        r"""equal(WaveformStreamID self, WaveformStreamID other) -> bool"""
        return _datamodel.WaveformStreamID_equal(self, other)

    def setNetworkCode(self, networkCode):
        r"""setNetworkCode(WaveformStreamID self, std::string const & networkCode)"""
        return _datamodel.WaveformStreamID_setNetworkCode(self, networkCode)

    def networkCode(self):
        r"""networkCode(WaveformStreamID self) -> std::string const &"""
        return _datamodel.WaveformStreamID_networkCode(self)

    def setStationCode(self, stationCode):
        r"""setStationCode(WaveformStreamID self, std::string const & stationCode)"""
        return _datamodel.WaveformStreamID_setStationCode(self, stationCode)

    def stationCode(self):
        r"""stationCode(WaveformStreamID self) -> std::string const &"""
        return _datamodel.WaveformStreamID_stationCode(self)

    def setLocationCode(self, locationCode):
        r"""setLocationCode(WaveformStreamID self, std::string const & locationCode)"""
        return _datamodel.WaveformStreamID_setLocationCode(self, locationCode)

    def locationCode(self):
        r"""locationCode(WaveformStreamID self) -> std::string const &"""
        return _datamodel.WaveformStreamID_locationCode(self)

    def setChannelCode(self, channelCode):
        r"""setChannelCode(WaveformStreamID self, std::string const & channelCode)"""
        return _datamodel.WaveformStreamID_setChannelCode(self, channelCode)

    def channelCode(self):
        r"""channelCode(WaveformStreamID self) -> std::string const &"""
        return _datamodel.WaveformStreamID_channelCode(self)

    def setResourceURI(self, resourceURI):
        r"""setResourceURI(WaveformStreamID self, std::string const & resourceURI)"""
        return _datamodel.WaveformStreamID_setResourceURI(self, resourceURI)

    def resourceURI(self):
        r"""resourceURI(WaveformStreamID self) -> std::string const &"""
        return _datamodel.WaveformStreamID_resourceURI(self)

# Register WaveformStreamID in _datamodel:
_datamodel.WaveformStreamID_swigregister(WaveformStreamID)

def WaveformStreamID_ClassName():
    r"""WaveformStreamID_ClassName() -> char const *"""
    return _datamodel.WaveformStreamID_ClassName()

def WaveformStreamID_TypeInfo():
    r"""WaveformStreamID_TypeInfo() -> RTTI"""
    return _datamodel.WaveformStreamID_TypeInfo()

def WaveformStreamID_Cast(*args):
    r"""
    WaveformStreamID_Cast(BaseObject o) -> WaveformStreamID
    WaveformStreamID_Cast(Seiscomp::Core::BaseObjectPtr o) -> WaveformStreamID
    """
    return _datamodel.WaveformStreamID_Cast(*args)

def WaveformStreamID_ConstCast(*args):
    r"""
    WaveformStreamID_ConstCast(BaseObject o) -> WaveformStreamID
    WaveformStreamID_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> WaveformStreamID
    """
    return _datamodel.WaveformStreamID_ConstCast(*args)

def WaveformStreamID_Meta():
    r"""WaveformStreamID_Meta() -> MetaObject"""
    return _datamodel.WaveformStreamID_Meta()

class SourceTimeFunction(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::SourceTimeFunction 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 _datamodel.SourceTimeFunction_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.SourceTimeFunction_TypeInfo()

    def className(self):
        r"""className(SourceTimeFunction self) -> char const *"""
        return _datamodel.SourceTimeFunction_className(self)

    def typeInfo(self):
        r"""typeInfo(SourceTimeFunction self) -> RTTI"""
        return _datamodel.SourceTimeFunction_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> SourceTimeFunction
        Cast(Seiscomp::Core::BaseObjectPtr o) -> SourceTimeFunction
        """
        return _datamodel.SourceTimeFunction_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> SourceTimeFunction
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SourceTimeFunction
        """
        return _datamodel.SourceTimeFunction_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(SourceTimeFunction self, GenericArchive ar)"""
        return _datamodel.SourceTimeFunction_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.SourceTimeFunction_Meta()

    def meta(self):
        r"""meta(SourceTimeFunction self) -> MetaObject"""
        return _datamodel.SourceTimeFunction_meta(self)

    def __init__(self, *args):
        r"""
        __init__(SourceTimeFunction self) -> SourceTimeFunction
        __init__(SourceTimeFunction self, SourceTimeFunction other) -> SourceTimeFunction
        """
        _datamodel.SourceTimeFunction_swiginit(self, _datamodel.new_SourceTimeFunction(*args))
    __swig_destroy__ = _datamodel.delete_SourceTimeFunction

    def __eq__(self, other):
        r"""__eq__(SourceTimeFunction self, SourceTimeFunction other) -> bool"""
        return _datamodel.SourceTimeFunction___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(SourceTimeFunction self, SourceTimeFunction other) -> bool"""
        return _datamodel.SourceTimeFunction___ne__(self, other)

    def equal(self, other):
        r"""equal(SourceTimeFunction self, SourceTimeFunction other) -> bool"""
        return _datamodel.SourceTimeFunction_equal(self, other)

    def setType(self, type):
        r"""setType(SourceTimeFunction self, Seiscomp::DataModel::SourceTimeFunctionType type)"""
        return _datamodel.SourceTimeFunction_setType(self, type)

    def type(self):
        r"""type(SourceTimeFunction self) -> Seiscomp::DataModel::SourceTimeFunctionType"""
        return _datamodel.SourceTimeFunction_type(self)

    def setDuration(self, duration):
        r"""setDuration(SourceTimeFunction self, double duration)"""
        return _datamodel.SourceTimeFunction_setDuration(self, duration)

    def duration(self):
        r"""duration(SourceTimeFunction self) -> double"""
        return _datamodel.SourceTimeFunction_duration(self)

    def setRiseTime(self, riseTime):
        r"""setRiseTime(SourceTimeFunction self, Seiscomp::Core::Optional< double >::Impl const & riseTime)"""
        return _datamodel.SourceTimeFunction_setRiseTime(self, riseTime)

    def riseTime(self):
        r"""riseTime(SourceTimeFunction self) -> double"""
        return _datamodel.SourceTimeFunction_riseTime(self)

    def setDecayTime(self, decayTime):
        r"""setDecayTime(SourceTimeFunction self, Seiscomp::Core::Optional< double >::Impl const & decayTime)"""
        return _datamodel.SourceTimeFunction_setDecayTime(self, decayTime)

    def decayTime(self):
        r"""decayTime(SourceTimeFunction self) -> double"""
        return _datamodel.SourceTimeFunction_decayTime(self)

# Register SourceTimeFunction in _datamodel:
_datamodel.SourceTimeFunction_swigregister(SourceTimeFunction)

def SourceTimeFunction_ClassName():
    r"""SourceTimeFunction_ClassName() -> char const *"""
    return _datamodel.SourceTimeFunction_ClassName()

def SourceTimeFunction_TypeInfo():
    r"""SourceTimeFunction_TypeInfo() -> RTTI"""
    return _datamodel.SourceTimeFunction_TypeInfo()

def SourceTimeFunction_Cast(*args):
    r"""
    SourceTimeFunction_Cast(BaseObject o) -> SourceTimeFunction
    SourceTimeFunction_Cast(Seiscomp::Core::BaseObjectPtr o) -> SourceTimeFunction
    """
    return _datamodel.SourceTimeFunction_Cast(*args)

def SourceTimeFunction_ConstCast(*args):
    r"""
    SourceTimeFunction_ConstCast(BaseObject o) -> SourceTimeFunction
    SourceTimeFunction_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SourceTimeFunction
    """
    return _datamodel.SourceTimeFunction_ConstCast(*args)

def SourceTimeFunction_Meta():
    r"""SourceTimeFunction_Meta() -> MetaObject"""
    return _datamodel.SourceTimeFunction_Meta()

class NodalPlanes(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::NodalPlanes 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 _datamodel.NodalPlanes_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.NodalPlanes_TypeInfo()

    def className(self):
        r"""className(NodalPlanes self) -> char const *"""
        return _datamodel.NodalPlanes_className(self)

    def typeInfo(self):
        r"""typeInfo(NodalPlanes self) -> RTTI"""
        return _datamodel.NodalPlanes_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> NodalPlanes
        Cast(Seiscomp::Core::BaseObjectPtr o) -> NodalPlanes
        """
        return _datamodel.NodalPlanes_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> NodalPlanes
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NodalPlanes
        """
        return _datamodel.NodalPlanes_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(NodalPlanes self, GenericArchive ar)"""
        return _datamodel.NodalPlanes_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.NodalPlanes_Meta()

    def meta(self):
        r"""meta(NodalPlanes self) -> MetaObject"""
        return _datamodel.NodalPlanes_meta(self)

    def __init__(self, *args):
        r"""
        __init__(NodalPlanes self) -> NodalPlanes
        __init__(NodalPlanes self, NodalPlanes other) -> NodalPlanes
        """
        _datamodel.NodalPlanes_swiginit(self, _datamodel.new_NodalPlanes(*args))
    __swig_destroy__ = _datamodel.delete_NodalPlanes

    def __eq__(self, other):
        r"""__eq__(NodalPlanes self, NodalPlanes other) -> bool"""
        return _datamodel.NodalPlanes___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(NodalPlanes self, NodalPlanes other) -> bool"""
        return _datamodel.NodalPlanes___ne__(self, other)

    def equal(self, other):
        r"""equal(NodalPlanes self, NodalPlanes other) -> bool"""
        return _datamodel.NodalPlanes_equal(self, other)

    def setNodalPlane1(self, nodalPlane1):
        r"""setNodalPlane1(NodalPlanes self, Seiscomp::Core::Optional< Seiscomp::DataModel::NodalPlane >::Impl const & nodalPlane1)"""
        return _datamodel.NodalPlanes_setNodalPlane1(self, nodalPlane1)

    def nodalPlane1(self, *args):
        r"""
        nodalPlane1(NodalPlanes self) -> NodalPlane
        nodalPlane1(NodalPlanes self) -> NodalPlane
        """
        return _datamodel.NodalPlanes_nodalPlane1(self, *args)

    def setNodalPlane2(self, nodalPlane2):
        r"""setNodalPlane2(NodalPlanes self, Seiscomp::Core::Optional< Seiscomp::DataModel::NodalPlane >::Impl const & nodalPlane2)"""
        return _datamodel.NodalPlanes_setNodalPlane2(self, nodalPlane2)

    def nodalPlane2(self, *args):
        r"""
        nodalPlane2(NodalPlanes self) -> NodalPlane
        nodalPlane2(NodalPlanes self) -> NodalPlane
        """
        return _datamodel.NodalPlanes_nodalPlane2(self, *args)

    def setPreferredPlane(self, preferredPlane):
        r"""setPreferredPlane(NodalPlanes self, Seiscomp::Core::Optional< int >::Impl const & preferredPlane)"""
        return _datamodel.NodalPlanes_setPreferredPlane(self, preferredPlane)

    def preferredPlane(self):
        r"""preferredPlane(NodalPlanes self) -> int"""
        return _datamodel.NodalPlanes_preferredPlane(self)

# Register NodalPlanes in _datamodel:
_datamodel.NodalPlanes_swigregister(NodalPlanes)

def NodalPlanes_ClassName():
    r"""NodalPlanes_ClassName() -> char const *"""
    return _datamodel.NodalPlanes_ClassName()

def NodalPlanes_TypeInfo():
    r"""NodalPlanes_TypeInfo() -> RTTI"""
    return _datamodel.NodalPlanes_TypeInfo()

def NodalPlanes_Cast(*args):
    r"""
    NodalPlanes_Cast(BaseObject o) -> NodalPlanes
    NodalPlanes_Cast(Seiscomp::Core::BaseObjectPtr o) -> NodalPlanes
    """
    return _datamodel.NodalPlanes_Cast(*args)

def NodalPlanes_ConstCast(*args):
    r"""
    NodalPlanes_ConstCast(BaseObject o) -> NodalPlanes
    NodalPlanes_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NodalPlanes
    """
    return _datamodel.NodalPlanes_ConstCast(*args)

def NodalPlanes_Meta():
    r"""NodalPlanes_Meta() -> MetaObject"""
    return _datamodel.NodalPlanes_Meta()

class ConfidenceEllipsoid(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::ConfidenceEllipsoid 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 _datamodel.ConfidenceEllipsoid_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ConfidenceEllipsoid_TypeInfo()

    def className(self):
        r"""className(ConfidenceEllipsoid self) -> char const *"""
        return _datamodel.ConfidenceEllipsoid_className(self)

    def typeInfo(self):
        r"""typeInfo(ConfidenceEllipsoid self) -> RTTI"""
        return _datamodel.ConfidenceEllipsoid_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ConfidenceEllipsoid
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfidenceEllipsoid
        """
        return _datamodel.ConfidenceEllipsoid_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ConfidenceEllipsoid
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfidenceEllipsoid
        """
        return _datamodel.ConfidenceEllipsoid_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ConfidenceEllipsoid self, GenericArchive ar)"""
        return _datamodel.ConfidenceEllipsoid_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ConfidenceEllipsoid_Meta()

    def meta(self):
        r"""meta(ConfidenceEllipsoid self) -> MetaObject"""
        return _datamodel.ConfidenceEllipsoid_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ConfidenceEllipsoid self) -> ConfidenceEllipsoid
        __init__(ConfidenceEllipsoid self, ConfidenceEllipsoid other) -> ConfidenceEllipsoid
        """
        _datamodel.ConfidenceEllipsoid_swiginit(self, _datamodel.new_ConfidenceEllipsoid(*args))
    __swig_destroy__ = _datamodel.delete_ConfidenceEllipsoid

    def __eq__(self, other):
        r"""__eq__(ConfidenceEllipsoid self, ConfidenceEllipsoid other) -> bool"""
        return _datamodel.ConfidenceEllipsoid___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ConfidenceEllipsoid self, ConfidenceEllipsoid other) -> bool"""
        return _datamodel.ConfidenceEllipsoid___ne__(self, other)

    def equal(self, other):
        r"""equal(ConfidenceEllipsoid self, ConfidenceEllipsoid other) -> bool"""
        return _datamodel.ConfidenceEllipsoid_equal(self, other)

    def setSemiMajorAxisLength(self, semiMajorAxisLength):
        r"""setSemiMajorAxisLength(ConfidenceEllipsoid self, double semiMajorAxisLength)"""
        return _datamodel.ConfidenceEllipsoid_setSemiMajorAxisLength(self, semiMajorAxisLength)

    def semiMajorAxisLength(self):
        r"""semiMajorAxisLength(ConfidenceEllipsoid self) -> double"""
        return _datamodel.ConfidenceEllipsoid_semiMajorAxisLength(self)

    def setSemiMinorAxisLength(self, semiMinorAxisLength):
        r"""setSemiMinorAxisLength(ConfidenceEllipsoid self, double semiMinorAxisLength)"""
        return _datamodel.ConfidenceEllipsoid_setSemiMinorAxisLength(self, semiMinorAxisLength)

    def semiMinorAxisLength(self):
        r"""semiMinorAxisLength(ConfidenceEllipsoid self) -> double"""
        return _datamodel.ConfidenceEllipsoid_semiMinorAxisLength(self)

    def setSemiIntermediateAxisLength(self, semiIntermediateAxisLength):
        r"""setSemiIntermediateAxisLength(ConfidenceEllipsoid self, double semiIntermediateAxisLength)"""
        return _datamodel.ConfidenceEllipsoid_setSemiIntermediateAxisLength(self, semiIntermediateAxisLength)

    def semiIntermediateAxisLength(self):
        r"""semiIntermediateAxisLength(ConfidenceEllipsoid self) -> double"""
        return _datamodel.ConfidenceEllipsoid_semiIntermediateAxisLength(self)

    def setMajorAxisPlunge(self, majorAxisPlunge):
        r"""setMajorAxisPlunge(ConfidenceEllipsoid self, double majorAxisPlunge)"""
        return _datamodel.ConfidenceEllipsoid_setMajorAxisPlunge(self, majorAxisPlunge)

    def majorAxisPlunge(self):
        r"""majorAxisPlunge(ConfidenceEllipsoid self) -> double"""
        return _datamodel.ConfidenceEllipsoid_majorAxisPlunge(self)

    def setMajorAxisAzimuth(self, majorAxisAzimuth):
        r"""setMajorAxisAzimuth(ConfidenceEllipsoid self, double majorAxisAzimuth)"""
        return _datamodel.ConfidenceEllipsoid_setMajorAxisAzimuth(self, majorAxisAzimuth)

    def majorAxisAzimuth(self):
        r"""majorAxisAzimuth(ConfidenceEllipsoid self) -> double"""
        return _datamodel.ConfidenceEllipsoid_majorAxisAzimuth(self)

    def setMajorAxisRotation(self, majorAxisRotation):
        r"""setMajorAxisRotation(ConfidenceEllipsoid self, double majorAxisRotation)"""
        return _datamodel.ConfidenceEllipsoid_setMajorAxisRotation(self, majorAxisRotation)

    def majorAxisRotation(self):
        r"""majorAxisRotation(ConfidenceEllipsoid self) -> double"""
        return _datamodel.ConfidenceEllipsoid_majorAxisRotation(self)

# Register ConfidenceEllipsoid in _datamodel:
_datamodel.ConfidenceEllipsoid_swigregister(ConfidenceEllipsoid)

def ConfidenceEllipsoid_ClassName():
    r"""ConfidenceEllipsoid_ClassName() -> char const *"""
    return _datamodel.ConfidenceEllipsoid_ClassName()

def ConfidenceEllipsoid_TypeInfo():
    r"""ConfidenceEllipsoid_TypeInfo() -> RTTI"""
    return _datamodel.ConfidenceEllipsoid_TypeInfo()

def ConfidenceEllipsoid_Cast(*args):
    r"""
    ConfidenceEllipsoid_Cast(BaseObject o) -> ConfidenceEllipsoid
    ConfidenceEllipsoid_Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfidenceEllipsoid
    """
    return _datamodel.ConfidenceEllipsoid_Cast(*args)

def ConfidenceEllipsoid_ConstCast(*args):
    r"""
    ConfidenceEllipsoid_ConstCast(BaseObject o) -> ConfidenceEllipsoid
    ConfidenceEllipsoid_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfidenceEllipsoid
    """
    return _datamodel.ConfidenceEllipsoid_ConstCast(*args)

def ConfidenceEllipsoid_Meta():
    r"""ConfidenceEllipsoid_Meta() -> MetaObject"""
    return _datamodel.ConfidenceEllipsoid_Meta()

class OriginUncertainty(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::OriginUncertainty 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 _datamodel.OriginUncertainty_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.OriginUncertainty_TypeInfo()

    def className(self):
        r"""className(OriginUncertainty self) -> char const *"""
        return _datamodel.OriginUncertainty_className(self)

    def typeInfo(self):
        r"""typeInfo(OriginUncertainty self) -> RTTI"""
        return _datamodel.OriginUncertainty_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> OriginUncertainty
        Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginUncertainty
        """
        return _datamodel.OriginUncertainty_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> OriginUncertainty
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginUncertainty
        """
        return _datamodel.OriginUncertainty_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(OriginUncertainty self, GenericArchive ar)"""
        return _datamodel.OriginUncertainty_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.OriginUncertainty_Meta()

    def meta(self):
        r"""meta(OriginUncertainty self) -> MetaObject"""
        return _datamodel.OriginUncertainty_meta(self)

    def __init__(self, *args):
        r"""
        __init__(OriginUncertainty self) -> OriginUncertainty
        __init__(OriginUncertainty self, OriginUncertainty other) -> OriginUncertainty
        """
        _datamodel.OriginUncertainty_swiginit(self, _datamodel.new_OriginUncertainty(*args))
    __swig_destroy__ = _datamodel.delete_OriginUncertainty

    def __eq__(self, other):
        r"""__eq__(OriginUncertainty self, OriginUncertainty other) -> bool"""
        return _datamodel.OriginUncertainty___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(OriginUncertainty self, OriginUncertainty other) -> bool"""
        return _datamodel.OriginUncertainty___ne__(self, other)

    def equal(self, other):
        r"""equal(OriginUncertainty self, OriginUncertainty other) -> bool"""
        return _datamodel.OriginUncertainty_equal(self, other)

    def setHorizontalUncertainty(self, horizontalUncertainty):
        r"""setHorizontalUncertainty(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & horizontalUncertainty)"""
        return _datamodel.OriginUncertainty_setHorizontalUncertainty(self, horizontalUncertainty)

    def horizontalUncertainty(self):
        r"""horizontalUncertainty(OriginUncertainty self) -> double"""
        return _datamodel.OriginUncertainty_horizontalUncertainty(self)

    def setMinHorizontalUncertainty(self, minHorizontalUncertainty):
        r"""setMinHorizontalUncertainty(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & minHorizontalUncertainty)"""
        return _datamodel.OriginUncertainty_setMinHorizontalUncertainty(self, minHorizontalUncertainty)

    def minHorizontalUncertainty(self):
        r"""minHorizontalUncertainty(OriginUncertainty self) -> double"""
        return _datamodel.OriginUncertainty_minHorizontalUncertainty(self)

    def setMaxHorizontalUncertainty(self, maxHorizontalUncertainty):
        r"""setMaxHorizontalUncertainty(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & maxHorizontalUncertainty)"""
        return _datamodel.OriginUncertainty_setMaxHorizontalUncertainty(self, maxHorizontalUncertainty)

    def maxHorizontalUncertainty(self):
        r"""maxHorizontalUncertainty(OriginUncertainty self) -> double"""
        return _datamodel.OriginUncertainty_maxHorizontalUncertainty(self)

    def setAzimuthMaxHorizontalUncertainty(self, azimuthMaxHorizontalUncertainty):
        r"""setAzimuthMaxHorizontalUncertainty(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & azimuthMaxHorizontalUncertainty)"""
        return _datamodel.OriginUncertainty_setAzimuthMaxHorizontalUncertainty(self, azimuthMaxHorizontalUncertainty)

    def azimuthMaxHorizontalUncertainty(self):
        r"""azimuthMaxHorizontalUncertainty(OriginUncertainty self) -> double"""
        return _datamodel.OriginUncertainty_azimuthMaxHorizontalUncertainty(self)

    def setConfidenceEllipsoid(self, confidenceEllipsoid):
        r"""setConfidenceEllipsoid(OriginUncertainty self, Seiscomp::Core::Optional< Seiscomp::DataModel::ConfidenceEllipsoid >::Impl const & confidenceEllipsoid)"""
        return _datamodel.OriginUncertainty_setConfidenceEllipsoid(self, confidenceEllipsoid)

    def confidenceEllipsoid(self, *args):
        r"""
        confidenceEllipsoid(OriginUncertainty self) -> ConfidenceEllipsoid
        confidenceEllipsoid(OriginUncertainty self) -> ConfidenceEllipsoid
        """
        return _datamodel.OriginUncertainty_confidenceEllipsoid(self, *args)

    def setPreferredDescription(self, preferredDescription):
        r"""setPreferredDescription(OriginUncertainty self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginUncertaintyDescription >::Impl const & preferredDescription)"""
        return _datamodel.OriginUncertainty_setPreferredDescription(self, preferredDescription)

    def preferredDescription(self):
        r"""preferredDescription(OriginUncertainty self) -> Seiscomp::DataModel::OriginUncertaintyDescription"""
        return _datamodel.OriginUncertainty_preferredDescription(self)

    def setConfidenceLevel(self, confidenceLevel):
        r"""setConfidenceLevel(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel)"""
        return _datamodel.OriginUncertainty_setConfidenceLevel(self, confidenceLevel)

    def confidenceLevel(self):
        r"""confidenceLevel(OriginUncertainty self) -> double"""
        return _datamodel.OriginUncertainty_confidenceLevel(self)

# Register OriginUncertainty in _datamodel:
_datamodel.OriginUncertainty_swigregister(OriginUncertainty)

def OriginUncertainty_ClassName():
    r"""OriginUncertainty_ClassName() -> char const *"""
    return _datamodel.OriginUncertainty_ClassName()

def OriginUncertainty_TypeInfo():
    r"""OriginUncertainty_TypeInfo() -> RTTI"""
    return _datamodel.OriginUncertainty_TypeInfo()

def OriginUncertainty_Cast(*args):
    r"""
    OriginUncertainty_Cast(BaseObject o) -> OriginUncertainty
    OriginUncertainty_Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginUncertainty
    """
    return _datamodel.OriginUncertainty_Cast(*args)

def OriginUncertainty_ConstCast(*args):
    r"""
    OriginUncertainty_ConstCast(BaseObject o) -> OriginUncertainty
    OriginUncertainty_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginUncertainty
    """
    return _datamodel.OriginUncertainty_ConstCast(*args)

def OriginUncertainty_Meta():
    r"""OriginUncertainty_Meta() -> MetaObject"""
    return _datamodel.OriginUncertainty_Meta()

class Blob(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::Blob 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 _datamodel.Blob_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Blob_TypeInfo()

    def className(self):
        r"""className(Blob self) -> char const *"""
        return _datamodel.Blob_className(self)

    def typeInfo(self):
        r"""typeInfo(Blob self) -> RTTI"""
        return _datamodel.Blob_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Blob
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Blob
        """
        return _datamodel.Blob_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Blob
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Blob
        """
        return _datamodel.Blob_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Blob self, GenericArchive ar)"""
        return _datamodel.Blob_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Blob_Meta()

    def meta(self):
        r"""meta(Blob self) -> MetaObject"""
        return _datamodel.Blob_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Blob self) -> Blob
        __init__(Blob self, Blob other) -> Blob
        """
        _datamodel.Blob_swiginit(self, _datamodel.new_Blob(*args))
    __swig_destroy__ = _datamodel.delete_Blob

    def __eq__(self, other):
        r"""__eq__(Blob self, Blob other) -> bool"""
        return _datamodel.Blob___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Blob self, Blob other) -> bool"""
        return _datamodel.Blob___ne__(self, other)

    def equal(self, other):
        r"""equal(Blob self, Blob other) -> bool"""
        return _datamodel.Blob_equal(self, other)

    def setContent(self, content):
        r"""setContent(Blob self, std::string const & content)"""
        return _datamodel.Blob_setContent(self, content)

    def content(self):
        r"""content(Blob self) -> std::string const &"""
        return _datamodel.Blob_content(self)

# Register Blob in _datamodel:
_datamodel.Blob_swigregister(Blob)

def Blob_ClassName():
    r"""Blob_ClassName() -> char const *"""
    return _datamodel.Blob_ClassName()

def Blob_TypeInfo():
    r"""Blob_TypeInfo() -> RTTI"""
    return _datamodel.Blob_TypeInfo()

def Blob_Cast(*args):
    r"""
    Blob_Cast(BaseObject o) -> Blob
    Blob_Cast(Seiscomp::Core::BaseObjectPtr o) -> Blob
    """
    return _datamodel.Blob_Cast(*args)

def Blob_ConstCast(*args):
    r"""
    Blob_ConstCast(BaseObject o) -> Blob
    Blob_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Blob
    """
    return _datamodel.Blob_ConstCast(*args)

def Blob_Meta():
    r"""Blob_Meta() -> MetaObject"""
    return _datamodel.Blob_Meta()

class ArclinkRequestSummary(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequestSummary 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 _datamodel.ArclinkRequestSummary_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ArclinkRequestSummary_TypeInfo()

    def className(self):
        r"""className(ArclinkRequestSummary self) -> char const *"""
        return _datamodel.ArclinkRequestSummary_className(self)

    def typeInfo(self):
        r"""typeInfo(ArclinkRequestSummary self) -> RTTI"""
        return _datamodel.ArclinkRequestSummary_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArclinkRequestSummary
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequestSummary
        """
        return _datamodel.ArclinkRequestSummary_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArclinkRequestSummary
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequestSummary
        """
        return _datamodel.ArclinkRequestSummary_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ArclinkRequestSummary self, GenericArchive ar)"""
        return _datamodel.ArclinkRequestSummary_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ArclinkRequestSummary_Meta()

    def meta(self):
        r"""meta(ArclinkRequestSummary self) -> MetaObject"""
        return _datamodel.ArclinkRequestSummary_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ArclinkRequestSummary self) -> ArclinkRequestSummary
        __init__(ArclinkRequestSummary self, ArclinkRequestSummary other) -> ArclinkRequestSummary
        """
        _datamodel.ArclinkRequestSummary_swiginit(self, _datamodel.new_ArclinkRequestSummary(*args))
    __swig_destroy__ = _datamodel.delete_ArclinkRequestSummary

    def __eq__(self, other):
        r"""__eq__(ArclinkRequestSummary self, ArclinkRequestSummary other) -> bool"""
        return _datamodel.ArclinkRequestSummary___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ArclinkRequestSummary self, ArclinkRequestSummary other) -> bool"""
        return _datamodel.ArclinkRequestSummary___ne__(self, other)

    def equal(self, other):
        r"""equal(ArclinkRequestSummary self, ArclinkRequestSummary other) -> bool"""
        return _datamodel.ArclinkRequestSummary_equal(self, other)

    def setOkLineCount(self, okLineCount):
        r"""setOkLineCount(ArclinkRequestSummary self, int okLineCount)"""
        return _datamodel.ArclinkRequestSummary_setOkLineCount(self, okLineCount)

    def okLineCount(self):
        r"""okLineCount(ArclinkRequestSummary self) -> int"""
        return _datamodel.ArclinkRequestSummary_okLineCount(self)

    def setTotalLineCount(self, totalLineCount):
        r"""setTotalLineCount(ArclinkRequestSummary self, int totalLineCount)"""
        return _datamodel.ArclinkRequestSummary_setTotalLineCount(self, totalLineCount)

    def totalLineCount(self):
        r"""totalLineCount(ArclinkRequestSummary self) -> int"""
        return _datamodel.ArclinkRequestSummary_totalLineCount(self)

    def setAverageTimeWindow(self, averageTimeWindow):
        r"""setAverageTimeWindow(ArclinkRequestSummary self, int averageTimeWindow)"""
        return _datamodel.ArclinkRequestSummary_setAverageTimeWindow(self, averageTimeWindow)

    def averageTimeWindow(self):
        r"""averageTimeWindow(ArclinkRequestSummary self) -> int"""
        return _datamodel.ArclinkRequestSummary_averageTimeWindow(self)

# Register ArclinkRequestSummary in _datamodel:
_datamodel.ArclinkRequestSummary_swigregister(ArclinkRequestSummary)

def ArclinkRequestSummary_ClassName():
    r"""ArclinkRequestSummary_ClassName() -> char const *"""
    return _datamodel.ArclinkRequestSummary_ClassName()

def ArclinkRequestSummary_TypeInfo():
    r"""ArclinkRequestSummary_TypeInfo() -> RTTI"""
    return _datamodel.ArclinkRequestSummary_TypeInfo()

def ArclinkRequestSummary_Cast(*args):
    r"""
    ArclinkRequestSummary_Cast(BaseObject o) -> ArclinkRequestSummary
    ArclinkRequestSummary_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequestSummary
    """
    return _datamodel.ArclinkRequestSummary_Cast(*args)

def ArclinkRequestSummary_ConstCast(*args):
    r"""
    ArclinkRequestSummary_ConstCast(BaseObject o) -> ArclinkRequestSummary
    ArclinkRequestSummary_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequestSummary
    """
    return _datamodel.ArclinkRequestSummary_ConstCast(*args)

def ArclinkRequestSummary_Meta():
    r"""ArclinkRequestSummary_Meta() -> MetaObject"""
    return _datamodel.ArclinkRequestSummary_Meta()

class EventDescriptionIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::EventDescriptionIndex 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__(EventDescriptionIndex self) -> EventDescriptionIndex
        __init__(EventDescriptionIndex self, Seiscomp::DataModel::EventDescriptionType type) -> EventDescriptionIndex
        __init__(EventDescriptionIndex self, EventDescriptionIndex arg2) -> EventDescriptionIndex
        """
        _datamodel.EventDescriptionIndex_swiginit(self, _datamodel.new_EventDescriptionIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(EventDescriptionIndex self, EventDescriptionIndex arg2) -> bool"""
        return _datamodel.EventDescriptionIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(EventDescriptionIndex self, EventDescriptionIndex arg2) -> bool"""
        return _datamodel.EventDescriptionIndex___ne__(self, arg2)
    type = property(_datamodel.EventDescriptionIndex_type_get, _datamodel.EventDescriptionIndex_type_set, doc=r"""type : Seiscomp::DataModel::EventDescriptionType""")
    __swig_destroy__ = _datamodel.delete_EventDescriptionIndex

# Register EventDescriptionIndex in _datamodel:
_datamodel.EventDescriptionIndex_swigregister(EventDescriptionIndex)

class EventDescription(Object):
    r"""Proxy of C++ Seiscomp::DataModel::EventDescription 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 _datamodel.EventDescription_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.EventDescription_TypeInfo()

    def className(self):
        r"""className(EventDescription self) -> char const *"""
        return _datamodel.EventDescription_className(self)

    def typeInfo(self):
        r"""typeInfo(EventDescription self) -> RTTI"""
        return _datamodel.EventDescription_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> EventDescription
        Cast(Seiscomp::Core::BaseObjectPtr o) -> EventDescription
        """
        return _datamodel.EventDescription_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> EventDescription
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventDescription
        """
        return _datamodel.EventDescription_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(EventDescription self, GenericArchive ar)"""
        return _datamodel.EventDescription_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.EventDescription_Meta()

    def meta(self):
        r"""meta(EventDescription self) -> MetaObject"""
        return _datamodel.EventDescription_meta(self)

    def __init__(self, *args):
        r"""
        __init__(EventDescription self) -> EventDescription
        __init__(EventDescription self, EventDescription other) -> EventDescription
        __init__(EventDescription self, std::string const & text) -> EventDescription
        __init__(EventDescription self, std::string const & text, Seiscomp::DataModel::EventDescriptionType type) -> EventDescription
        """
        _datamodel.EventDescription_swiginit(self, _datamodel.new_EventDescription(*args))
    __swig_destroy__ = _datamodel.delete_EventDescription

    def __eq__(self, other):
        r"""__eq__(EventDescription self, EventDescription other) -> bool"""
        return _datamodel.EventDescription___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(EventDescription self, EventDescription other) -> bool"""
        return _datamodel.EventDescription___ne__(self, other)

    def equal(self, other):
        r"""equal(EventDescription self, EventDescription other) -> bool"""
        return _datamodel.EventDescription_equal(self, other)

    def setText(self, text):
        r"""setText(EventDescription self, std::string const & text)"""
        return _datamodel.EventDescription_setText(self, text)

    def text(self):
        r"""text(EventDescription self) -> std::string const &"""
        return _datamodel.EventDescription_text(self)

    def setType(self, type):
        r"""setType(EventDescription self, Seiscomp::DataModel::EventDescriptionType type)"""
        return _datamodel.EventDescription_setType(self, type)

    def type(self):
        r"""type(EventDescription self) -> Seiscomp::DataModel::EventDescriptionType"""
        return _datamodel.EventDescription_type(self)

    def index(self):
        r"""index(EventDescription self) -> EventDescriptionIndex"""
        return _datamodel.EventDescription_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(EventDescription self, EventDescription lhs) -> bool"""
        return _datamodel.EventDescription_equalIndex(self, lhs)

    def event(self):
        r"""event(EventDescription self) -> Event"""
        return _datamodel.EventDescription_event(self)

    def assign(self, other):
        r"""assign(EventDescription self, Object other) -> bool"""
        return _datamodel.EventDescription_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(EventDescription self, PublicObject parent) -> bool"""
        return _datamodel.EventDescription_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(EventDescription self, PublicObject parent) -> bool"""
        return _datamodel.EventDescription_detachFrom(self, parent)

    def detach(self):
        r"""detach(EventDescription self) -> bool"""
        return _datamodel.EventDescription_detach(self)

    def clone(self):
        r"""clone(EventDescription self) -> Object"""
        return _datamodel.EventDescription_clone(self)

    def accept(self, visitor):
        r"""accept(EventDescription self, Visitor visitor)"""
        return _datamodel.EventDescription_accept(self, visitor)

# Register EventDescription in _datamodel:
_datamodel.EventDescription_swigregister(EventDescription)

def EventDescription_ClassName():
    r"""EventDescription_ClassName() -> char const *"""
    return _datamodel.EventDescription_ClassName()

def EventDescription_TypeInfo():
    r"""EventDescription_TypeInfo() -> RTTI"""
    return _datamodel.EventDescription_TypeInfo()

def EventDescription_Cast(*args):
    r"""
    EventDescription_Cast(BaseObject o) -> EventDescription
    EventDescription_Cast(Seiscomp::Core::BaseObjectPtr o) -> EventDescription
    """
    return _datamodel.EventDescription_Cast(*args)

def EventDescription_ConstCast(*args):
    r"""
    EventDescription_ConstCast(BaseObject o) -> EventDescription
    EventDescription_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventDescription
    """
    return _datamodel.EventDescription_ConstCast(*args)

def EventDescription_Meta():
    r"""EventDescription_Meta() -> MetaObject"""
    return _datamodel.EventDescription_Meta()

class DataUsed(Object):
    r"""Proxy of C++ Seiscomp::DataModel::DataUsed 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 _datamodel.DataUsed_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.DataUsed_TypeInfo()

    def className(self):
        r"""className(DataUsed self) -> char const *"""
        return _datamodel.DataUsed_className(self)

    def typeInfo(self):
        r"""typeInfo(DataUsed self) -> RTTI"""
        return _datamodel.DataUsed_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DataUsed
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DataUsed
        """
        return _datamodel.DataUsed_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DataUsed
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataUsed
        """
        return _datamodel.DataUsed_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(DataUsed self, GenericArchive ar)"""
        return _datamodel.DataUsed_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.DataUsed_Meta()

    def meta(self):
        r"""meta(DataUsed self) -> MetaObject"""
        return _datamodel.DataUsed_meta(self)

    def __init__(self, *args):
        r"""
        __init__(DataUsed self) -> DataUsed
        __init__(DataUsed self, DataUsed other) -> DataUsed
        """
        _datamodel.DataUsed_swiginit(self, _datamodel.new_DataUsed(*args))
    __swig_destroy__ = _datamodel.delete_DataUsed

    def __eq__(self, other):
        r"""__eq__(DataUsed self, DataUsed other) -> bool"""
        return _datamodel.DataUsed___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(DataUsed self, DataUsed other) -> bool"""
        return _datamodel.DataUsed___ne__(self, other)

    def equal(self, other):
        r"""equal(DataUsed self, DataUsed other) -> bool"""
        return _datamodel.DataUsed_equal(self, other)

    def setWaveType(self, waveType):
        r"""setWaveType(DataUsed self, Seiscomp::DataModel::DataUsedWaveType waveType)"""
        return _datamodel.DataUsed_setWaveType(self, waveType)

    def waveType(self):
        r"""waveType(DataUsed self) -> Seiscomp::DataModel::DataUsedWaveType"""
        return _datamodel.DataUsed_waveType(self)

    def setStationCount(self, stationCount):
        r"""setStationCount(DataUsed self, int stationCount)"""
        return _datamodel.DataUsed_setStationCount(self, stationCount)

    def stationCount(self):
        r"""stationCount(DataUsed self) -> int"""
        return _datamodel.DataUsed_stationCount(self)

    def setComponentCount(self, componentCount):
        r"""setComponentCount(DataUsed self, int componentCount)"""
        return _datamodel.DataUsed_setComponentCount(self, componentCount)

    def componentCount(self):
        r"""componentCount(DataUsed self) -> int"""
        return _datamodel.DataUsed_componentCount(self)

    def setShortestPeriod(self, shortestPeriod):
        r"""setShortestPeriod(DataUsed self, Seiscomp::Core::Optional< double >::Impl const & shortestPeriod)"""
        return _datamodel.DataUsed_setShortestPeriod(self, shortestPeriod)

    def shortestPeriod(self):
        r"""shortestPeriod(DataUsed self) -> double"""
        return _datamodel.DataUsed_shortestPeriod(self)

    def momentTensor(self):
        r"""momentTensor(DataUsed self) -> MomentTensor"""
        return _datamodel.DataUsed_momentTensor(self)

    def assign(self, other):
        r"""assign(DataUsed self, Object other) -> bool"""
        return _datamodel.DataUsed_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(DataUsed self, PublicObject parent) -> bool"""
        return _datamodel.DataUsed_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(DataUsed self, PublicObject parent) -> bool"""
        return _datamodel.DataUsed_detachFrom(self, parent)

    def detach(self):
        r"""detach(DataUsed self) -> bool"""
        return _datamodel.DataUsed_detach(self)

    def clone(self):
        r"""clone(DataUsed self) -> Object"""
        return _datamodel.DataUsed_clone(self)

    def accept(self, visitor):
        r"""accept(DataUsed self, Visitor visitor)"""
        return _datamodel.DataUsed_accept(self, visitor)

# Register DataUsed in _datamodel:
_datamodel.DataUsed_swigregister(DataUsed)

def DataUsed_ClassName():
    r"""DataUsed_ClassName() -> char const *"""
    return _datamodel.DataUsed_ClassName()

def DataUsed_TypeInfo():
    r"""DataUsed_TypeInfo() -> RTTI"""
    return _datamodel.DataUsed_TypeInfo()

def DataUsed_Cast(*args):
    r"""
    DataUsed_Cast(BaseObject o) -> DataUsed
    DataUsed_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataUsed
    """
    return _datamodel.DataUsed_Cast(*args)

def DataUsed_ConstCast(*args):
    r"""
    DataUsed_ConstCast(BaseObject o) -> DataUsed
    DataUsed_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataUsed
    """
    return _datamodel.DataUsed_ConstCast(*args)

def DataUsed_Meta():
    r"""DataUsed_Meta() -> MetaObject"""
    return _datamodel.DataUsed_Meta()

class CompositeTime(Object):
    r"""Proxy of C++ Seiscomp::DataModel::CompositeTime 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 _datamodel.CompositeTime_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.CompositeTime_TypeInfo()

    def className(self):
        r"""className(CompositeTime self) -> char const *"""
        return _datamodel.CompositeTime_className(self)

    def typeInfo(self):
        r"""typeInfo(CompositeTime self) -> RTTI"""
        return _datamodel.CompositeTime_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> CompositeTime
        Cast(Seiscomp::Core::BaseObjectPtr o) -> CompositeTime
        """
        return _datamodel.CompositeTime_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> CompositeTime
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> CompositeTime
        """
        return _datamodel.CompositeTime_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(CompositeTime self, GenericArchive ar)"""
        return _datamodel.CompositeTime_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.CompositeTime_Meta()

    def meta(self):
        r"""meta(CompositeTime self) -> MetaObject"""
        return _datamodel.CompositeTime_meta(self)

    def __init__(self, *args):
        r"""
        __init__(CompositeTime self) -> CompositeTime
        __init__(CompositeTime self, CompositeTime other) -> CompositeTime
        """
        _datamodel.CompositeTime_swiginit(self, _datamodel.new_CompositeTime(*args))
    __swig_destroy__ = _datamodel.delete_CompositeTime

    def __eq__(self, other):
        r"""__eq__(CompositeTime self, CompositeTime other) -> bool"""
        return _datamodel.CompositeTime___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(CompositeTime self, CompositeTime other) -> bool"""
        return _datamodel.CompositeTime___ne__(self, other)

    def equal(self, other):
        r"""equal(CompositeTime self, CompositeTime other) -> bool"""
        return _datamodel.CompositeTime_equal(self, other)

    def setYear(self, year):
        r"""setYear(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & year)"""
        return _datamodel.CompositeTime_setYear(self, year)

    def year(self, *args):
        r"""
        year(CompositeTime self) -> IntegerQuantity
        year(CompositeTime self) -> IntegerQuantity
        """
        return _datamodel.CompositeTime_year(self, *args)

    def setMonth(self, month):
        r"""setMonth(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & month)"""
        return _datamodel.CompositeTime_setMonth(self, month)

    def month(self, *args):
        r"""
        month(CompositeTime self) -> IntegerQuantity
        month(CompositeTime self) -> IntegerQuantity
        """
        return _datamodel.CompositeTime_month(self, *args)

    def setDay(self, day):
        r"""setDay(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & day)"""
        return _datamodel.CompositeTime_setDay(self, day)

    def day(self, *args):
        r"""
        day(CompositeTime self) -> IntegerQuantity
        day(CompositeTime self) -> IntegerQuantity
        """
        return _datamodel.CompositeTime_day(self, *args)

    def setHour(self, hour):
        r"""setHour(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & hour)"""
        return _datamodel.CompositeTime_setHour(self, hour)

    def hour(self, *args):
        r"""
        hour(CompositeTime self) -> IntegerQuantity
        hour(CompositeTime self) -> IntegerQuantity
        """
        return _datamodel.CompositeTime_hour(self, *args)

    def setMinute(self, minute):
        r"""setMinute(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & minute)"""
        return _datamodel.CompositeTime_setMinute(self, minute)

    def minute(self, *args):
        r"""
        minute(CompositeTime self) -> IntegerQuantity
        minute(CompositeTime self) -> IntegerQuantity
        """
        return _datamodel.CompositeTime_minute(self, *args)

    def setSecond(self, second):
        r"""setSecond(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & second)"""
        return _datamodel.CompositeTime_setSecond(self, second)

    def second(self, *args):
        r"""
        second(CompositeTime self) -> RealQuantity
        second(CompositeTime self) -> RealQuantity
        """
        return _datamodel.CompositeTime_second(self, *args)

    def origin(self):
        r"""origin(CompositeTime self) -> Origin"""
        return _datamodel.CompositeTime_origin(self)

    def assign(self, other):
        r"""assign(CompositeTime self, Object other) -> bool"""
        return _datamodel.CompositeTime_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(CompositeTime self, PublicObject parent) -> bool"""
        return _datamodel.CompositeTime_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(CompositeTime self, PublicObject parent) -> bool"""
        return _datamodel.CompositeTime_detachFrom(self, parent)

    def detach(self):
        r"""detach(CompositeTime self) -> bool"""
        return _datamodel.CompositeTime_detach(self)

    def clone(self):
        r"""clone(CompositeTime self) -> Object"""
        return _datamodel.CompositeTime_clone(self)

    def accept(self, visitor):
        r"""accept(CompositeTime self, Visitor visitor)"""
        return _datamodel.CompositeTime_accept(self, visitor)

# Register CompositeTime in _datamodel:
_datamodel.CompositeTime_swigregister(CompositeTime)

def CompositeTime_ClassName():
    r"""CompositeTime_ClassName() -> char const *"""
    return _datamodel.CompositeTime_ClassName()

def CompositeTime_TypeInfo():
    r"""CompositeTime_TypeInfo() -> RTTI"""
    return _datamodel.CompositeTime_TypeInfo()

def CompositeTime_Cast(*args):
    r"""
    CompositeTime_Cast(BaseObject o) -> CompositeTime
    CompositeTime_Cast(Seiscomp::Core::BaseObjectPtr o) -> CompositeTime
    """
    return _datamodel.CompositeTime_Cast(*args)

def CompositeTime_ConstCast(*args):
    r"""
    CompositeTime_ConstCast(BaseObject o) -> CompositeTime
    CompositeTime_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> CompositeTime
    """
    return _datamodel.CompositeTime_ConstCast(*args)

def CompositeTime_Meta():
    r"""CompositeTime_Meta() -> MetaObject"""
    return _datamodel.CompositeTime_Meta()

class PickReferenceIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::PickReferenceIndex 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__(PickReferenceIndex self) -> PickReferenceIndex
        __init__(PickReferenceIndex self, std::string const & pickID) -> PickReferenceIndex
        __init__(PickReferenceIndex self, PickReferenceIndex arg2) -> PickReferenceIndex
        """
        _datamodel.PickReferenceIndex_swiginit(self, _datamodel.new_PickReferenceIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(PickReferenceIndex self, PickReferenceIndex arg2) -> bool"""
        return _datamodel.PickReferenceIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(PickReferenceIndex self, PickReferenceIndex arg2) -> bool"""
        return _datamodel.PickReferenceIndex___ne__(self, arg2)
    pickID = property(_datamodel.PickReferenceIndex_pickID_get, _datamodel.PickReferenceIndex_pickID_set, doc=r"""pickID : std::string""")
    __swig_destroy__ = _datamodel.delete_PickReferenceIndex

# Register PickReferenceIndex in _datamodel:
_datamodel.PickReferenceIndex_swigregister(PickReferenceIndex)

class PickReference(Object):
    r"""Proxy of C++ Seiscomp::DataModel::PickReference 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 _datamodel.PickReference_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.PickReference_TypeInfo()

    def className(self):
        r"""className(PickReference self) -> char const *"""
        return _datamodel.PickReference_className(self)

    def typeInfo(self):
        r"""typeInfo(PickReference self) -> RTTI"""
        return _datamodel.PickReference_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> PickReference
        Cast(Seiscomp::Core::BaseObjectPtr o) -> PickReference
        """
        return _datamodel.PickReference_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> PickReference
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PickReference
        """
        return _datamodel.PickReference_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(PickReference self, GenericArchive ar)"""
        return _datamodel.PickReference_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.PickReference_Meta()

    def meta(self):
        r"""meta(PickReference self) -> MetaObject"""
        return _datamodel.PickReference_meta(self)

    def __init__(self, *args):
        r"""
        __init__(PickReference self) -> PickReference
        __init__(PickReference self, PickReference other) -> PickReference
        __init__(PickReference self, std::string const & pickID) -> PickReference
        """
        _datamodel.PickReference_swiginit(self, _datamodel.new_PickReference(*args))
    __swig_destroy__ = _datamodel.delete_PickReference

    def __eq__(self, other):
        r"""__eq__(PickReference self, PickReference other) -> bool"""
        return _datamodel.PickReference___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(PickReference self, PickReference other) -> bool"""
        return _datamodel.PickReference___ne__(self, other)

    def equal(self, other):
        r"""equal(PickReference self, PickReference other) -> bool"""
        return _datamodel.PickReference_equal(self, other)

    def setPickID(self, pickID):
        r"""setPickID(PickReference self, std::string const & pickID)"""
        return _datamodel.PickReference_setPickID(self, pickID)

    def pickID(self):
        r"""pickID(PickReference self) -> std::string const &"""
        return _datamodel.PickReference_pickID(self)

    def index(self):
        r"""index(PickReference self) -> PickReferenceIndex"""
        return _datamodel.PickReference_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(PickReference self, PickReference lhs) -> bool"""
        return _datamodel.PickReference_equalIndex(self, lhs)

    def reading(self):
        r"""reading(PickReference self) -> Reading"""
        return _datamodel.PickReference_reading(self)

    def assign(self, other):
        r"""assign(PickReference self, Object other) -> bool"""
        return _datamodel.PickReference_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(PickReference self, PublicObject parent) -> bool"""
        return _datamodel.PickReference_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(PickReference self, PublicObject parent) -> bool"""
        return _datamodel.PickReference_detachFrom(self, parent)

    def detach(self):
        r"""detach(PickReference self) -> bool"""
        return _datamodel.PickReference_detach(self)

    def clone(self):
        r"""clone(PickReference self) -> Object"""
        return _datamodel.PickReference_clone(self)

    def accept(self, visitor):
        r"""accept(PickReference self, Visitor visitor)"""
        return _datamodel.PickReference_accept(self, visitor)

# Register PickReference in _datamodel:
_datamodel.PickReference_swigregister(PickReference)

def PickReference_ClassName():
    r"""PickReference_ClassName() -> char const *"""
    return _datamodel.PickReference_ClassName()

def PickReference_TypeInfo():
    r"""PickReference_TypeInfo() -> RTTI"""
    return _datamodel.PickReference_TypeInfo()

def PickReference_Cast(*args):
    r"""
    PickReference_Cast(BaseObject o) -> PickReference
    PickReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> PickReference
    """
    return _datamodel.PickReference_Cast(*args)

def PickReference_ConstCast(*args):
    r"""
    PickReference_ConstCast(BaseObject o) -> PickReference
    PickReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PickReference
    """
    return _datamodel.PickReference_ConstCast(*args)

def PickReference_Meta():
    r"""PickReference_Meta() -> MetaObject"""
    return _datamodel.PickReference_Meta()

class AmplitudeReferenceIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::AmplitudeReferenceIndex 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__(AmplitudeReferenceIndex self) -> AmplitudeReferenceIndex
        __init__(AmplitudeReferenceIndex self, std::string const & amplitudeID) -> AmplitudeReferenceIndex
        __init__(AmplitudeReferenceIndex self, AmplitudeReferenceIndex arg2) -> AmplitudeReferenceIndex
        """
        _datamodel.AmplitudeReferenceIndex_swiginit(self, _datamodel.new_AmplitudeReferenceIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(AmplitudeReferenceIndex self, AmplitudeReferenceIndex arg2) -> bool"""
        return _datamodel.AmplitudeReferenceIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(AmplitudeReferenceIndex self, AmplitudeReferenceIndex arg2) -> bool"""
        return _datamodel.AmplitudeReferenceIndex___ne__(self, arg2)
    amplitudeID = property(_datamodel.AmplitudeReferenceIndex_amplitudeID_get, _datamodel.AmplitudeReferenceIndex_amplitudeID_set, doc=r"""amplitudeID : std::string""")
    __swig_destroy__ = _datamodel.delete_AmplitudeReferenceIndex

# Register AmplitudeReferenceIndex in _datamodel:
_datamodel.AmplitudeReferenceIndex_swigregister(AmplitudeReferenceIndex)

class AmplitudeReference(Object):
    r"""Proxy of C++ Seiscomp::DataModel::AmplitudeReference 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 _datamodel.AmplitudeReference_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.AmplitudeReference_TypeInfo()

    def className(self):
        r"""className(AmplitudeReference self) -> char const *"""
        return _datamodel.AmplitudeReference_className(self)

    def typeInfo(self):
        r"""typeInfo(AmplitudeReference self) -> RTTI"""
        return _datamodel.AmplitudeReference_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> AmplitudeReference
        Cast(Seiscomp::Core::BaseObjectPtr o) -> AmplitudeReference
        """
        return _datamodel.AmplitudeReference_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> AmplitudeReference
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AmplitudeReference
        """
        return _datamodel.AmplitudeReference_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(AmplitudeReference self, GenericArchive ar)"""
        return _datamodel.AmplitudeReference_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.AmplitudeReference_Meta()

    def meta(self):
        r"""meta(AmplitudeReference self) -> MetaObject"""
        return _datamodel.AmplitudeReference_meta(self)

    def __init__(self, *args):
        r"""
        __init__(AmplitudeReference self) -> AmplitudeReference
        __init__(AmplitudeReference self, AmplitudeReference other) -> AmplitudeReference
        __init__(AmplitudeReference self, std::string const & amplitudeID) -> AmplitudeReference
        """
        _datamodel.AmplitudeReference_swiginit(self, _datamodel.new_AmplitudeReference(*args))
    __swig_destroy__ = _datamodel.delete_AmplitudeReference

    def __eq__(self, other):
        r"""__eq__(AmplitudeReference self, AmplitudeReference other) -> bool"""
        return _datamodel.AmplitudeReference___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(AmplitudeReference self, AmplitudeReference other) -> bool"""
        return _datamodel.AmplitudeReference___ne__(self, other)

    def equal(self, other):
        r"""equal(AmplitudeReference self, AmplitudeReference other) -> bool"""
        return _datamodel.AmplitudeReference_equal(self, other)

    def setAmplitudeID(self, amplitudeID):
        r"""setAmplitudeID(AmplitudeReference self, std::string const & amplitudeID)"""
        return _datamodel.AmplitudeReference_setAmplitudeID(self, amplitudeID)

    def amplitudeID(self):
        r"""amplitudeID(AmplitudeReference self) -> std::string const &"""
        return _datamodel.AmplitudeReference_amplitudeID(self)

    def index(self):
        r"""index(AmplitudeReference self) -> AmplitudeReferenceIndex"""
        return _datamodel.AmplitudeReference_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(AmplitudeReference self, AmplitudeReference lhs) -> bool"""
        return _datamodel.AmplitudeReference_equalIndex(self, lhs)

    def reading(self):
        r"""reading(AmplitudeReference self) -> Reading"""
        return _datamodel.AmplitudeReference_reading(self)

    def assign(self, other):
        r"""assign(AmplitudeReference self, Object other) -> bool"""
        return _datamodel.AmplitudeReference_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(AmplitudeReference self, PublicObject parent) -> bool"""
        return _datamodel.AmplitudeReference_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(AmplitudeReference self, PublicObject parent) -> bool"""
        return _datamodel.AmplitudeReference_detachFrom(self, parent)

    def detach(self):
        r"""detach(AmplitudeReference self) -> bool"""
        return _datamodel.AmplitudeReference_detach(self)

    def clone(self):
        r"""clone(AmplitudeReference self) -> Object"""
        return _datamodel.AmplitudeReference_clone(self)

    def accept(self, visitor):
        r"""accept(AmplitudeReference self, Visitor visitor)"""
        return _datamodel.AmplitudeReference_accept(self, visitor)

# Register AmplitudeReference in _datamodel:
_datamodel.AmplitudeReference_swigregister(AmplitudeReference)

def AmplitudeReference_ClassName():
    r"""AmplitudeReference_ClassName() -> char const *"""
    return _datamodel.AmplitudeReference_ClassName()

def AmplitudeReference_TypeInfo():
    r"""AmplitudeReference_TypeInfo() -> RTTI"""
    return _datamodel.AmplitudeReference_TypeInfo()

def AmplitudeReference_Cast(*args):
    r"""
    AmplitudeReference_Cast(BaseObject o) -> AmplitudeReference
    AmplitudeReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> AmplitudeReference
    """
    return _datamodel.AmplitudeReference_Cast(*args)

def AmplitudeReference_ConstCast(*args):
    r"""
    AmplitudeReference_ConstCast(BaseObject o) -> AmplitudeReference
    AmplitudeReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AmplitudeReference
    """
    return _datamodel.AmplitudeReference_ConstCast(*args)

def AmplitudeReference_Meta():
    r"""AmplitudeReference_Meta() -> MetaObject"""
    return _datamodel.AmplitudeReference_Meta()

class Reading(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Reading 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 _datamodel.Reading_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Reading_TypeInfo()

    def className(self):
        r"""className(Reading self) -> char const *"""
        return _datamodel.Reading_className(self)

    def typeInfo(self):
        r"""typeInfo(Reading self) -> RTTI"""
        return _datamodel.Reading_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Reading
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Reading
        """
        return _datamodel.Reading_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Reading
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Reading
        """
        return _datamodel.Reading_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Reading self, GenericArchive ar)"""
        return _datamodel.Reading_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Reading_Meta()

    def meta(self):
        r"""meta(Reading self) -> MetaObject"""
        return _datamodel.Reading_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Reading self, Reading other) -> Reading
        __init__(Reading self, std::string const & publicID) -> Reading
        """
        _datamodel.Reading_swiginit(self, _datamodel.new_Reading(*args))
    __swig_destroy__ = _datamodel.delete_Reading

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Reading
        Create(std::string const & publicID) -> Reading
        """
        return _datamodel.Reading_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Reading"""
        return _datamodel.Reading_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Reading self, Reading other) -> bool"""
        return _datamodel.Reading___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Reading self, Reading other) -> bool"""
        return _datamodel.Reading___ne__(self, other)

    def equal(self, other):
        r"""equal(Reading self, Reading other) -> bool"""
        return _datamodel.Reading_equal(self, other)

    def add(self, *args):
        r"""
        add(Reading self, PickReference obj) -> bool
        add(Reading self, AmplitudeReference obj) -> bool
        """
        return _datamodel.Reading_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Reading self, PickReference obj) -> bool
        remove(Reading self, AmplitudeReference obj) -> bool
        """
        return _datamodel.Reading_remove(self, *args)

    def removePickReference(self, *args):
        r"""
        removePickReference(Reading self, size_t i) -> bool
        removePickReference(Reading self, PickReferenceIndex i) -> bool
        """
        return _datamodel.Reading_removePickReference(self, *args)

    def removeAmplitudeReference(self, *args):
        r"""
        removeAmplitudeReference(Reading self, size_t i) -> bool
        removeAmplitudeReference(Reading self, AmplitudeReferenceIndex i) -> bool
        """
        return _datamodel.Reading_removeAmplitudeReference(self, *args)

    def pickReferenceCount(self):
        r"""pickReferenceCount(Reading self) -> size_t"""
        return _datamodel.Reading_pickReferenceCount(self)

    def amplitudeReferenceCount(self):
        r"""amplitudeReferenceCount(Reading self) -> size_t"""
        return _datamodel.Reading_amplitudeReferenceCount(self)

    def pickReference(self, *args):
        r"""
        pickReference(Reading self, size_t i) -> PickReference
        pickReference(Reading self, PickReferenceIndex i) -> PickReference
        """
        return _datamodel.Reading_pickReference(self, *args)

    def amplitudeReference(self, *args):
        r"""
        amplitudeReference(Reading self, size_t i) -> AmplitudeReference
        amplitudeReference(Reading self, AmplitudeReferenceIndex i) -> AmplitudeReference
        """
        return _datamodel.Reading_amplitudeReference(self, *args)

    def eventParameters(self):
        r"""eventParameters(Reading self) -> EventParameters"""
        return _datamodel.Reading_eventParameters(self)

    def assign(self, other):
        r"""assign(Reading self, Object other) -> bool"""
        return _datamodel.Reading_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Reading self, PublicObject parent) -> bool"""
        return _datamodel.Reading_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Reading self, PublicObject parent) -> bool"""
        return _datamodel.Reading_detachFrom(self, parent)

    def detach(self):
        r"""detach(Reading self) -> bool"""
        return _datamodel.Reading_detach(self)

    def clone(self):
        r"""clone(Reading self) -> Object"""
        return _datamodel.Reading_clone(self)

    def updateChild(self, child):
        r"""updateChild(Reading self, Object child) -> bool"""
        return _datamodel.Reading_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Reading self, Visitor visitor)"""
        return _datamodel.Reading_accept(self, visitor)

# Register Reading in _datamodel:
_datamodel.Reading_swigregister(Reading)

def Reading_ClassName():
    r"""Reading_ClassName() -> char const *"""
    return _datamodel.Reading_ClassName()

def Reading_TypeInfo():
    r"""Reading_TypeInfo() -> RTTI"""
    return _datamodel.Reading_TypeInfo()

def Reading_Cast(*args):
    r"""
    Reading_Cast(BaseObject o) -> Reading
    Reading_Cast(Seiscomp::Core::BaseObjectPtr o) -> Reading
    """
    return _datamodel.Reading_Cast(*args)

def Reading_ConstCast(*args):
    r"""
    Reading_ConstCast(BaseObject o) -> Reading
    Reading_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Reading
    """
    return _datamodel.Reading_ConstCast(*args)

def Reading_Meta():
    r"""Reading_Meta() -> MetaObject"""
    return _datamodel.Reading_Meta()

def Reading_Create(*args):
    r"""
    Reading_Create() -> Reading
    Reading_Create(std::string const & publicID) -> Reading
    """
    return _datamodel.Reading_Create(*args)

def Reading_Find(publicID):
    r"""Reading_Find(std::string const & publicID) -> Reading"""
    return _datamodel.Reading_Find(publicID)

class MomentTensorComponentContributionIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::MomentTensorComponentContributionIndex 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__(MomentTensorComponentContributionIndex self) -> MomentTensorComponentContributionIndex
        __init__(MomentTensorComponentContributionIndex self, std::string const & phaseCode, int component) -> MomentTensorComponentContributionIndex
        __init__(MomentTensorComponentContributionIndex self, MomentTensorComponentContributionIndex arg2) -> MomentTensorComponentContributionIndex
        """
        _datamodel.MomentTensorComponentContributionIndex_swiginit(self, _datamodel.new_MomentTensorComponentContributionIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(MomentTensorComponentContributionIndex self, MomentTensorComponentContributionIndex arg2) -> bool"""
        return _datamodel.MomentTensorComponentContributionIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(MomentTensorComponentContributionIndex self, MomentTensorComponentContributionIndex arg2) -> bool"""
        return _datamodel.MomentTensorComponentContributionIndex___ne__(self, arg2)
    phaseCode = property(_datamodel.MomentTensorComponentContributionIndex_phaseCode_get, _datamodel.MomentTensorComponentContributionIndex_phaseCode_set, doc=r"""phaseCode : std::string""")
    component = property(_datamodel.MomentTensorComponentContributionIndex_component_get, _datamodel.MomentTensorComponentContributionIndex_component_set, doc=r"""component : int""")
    __swig_destroy__ = _datamodel.delete_MomentTensorComponentContributionIndex

# Register MomentTensorComponentContributionIndex in _datamodel:
_datamodel.MomentTensorComponentContributionIndex_swigregister(MomentTensorComponentContributionIndex)

class MomentTensorComponentContribution(Object):
    r"""Proxy of C++ Seiscomp::DataModel::MomentTensorComponentContribution 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 _datamodel.MomentTensorComponentContribution_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.MomentTensorComponentContribution_TypeInfo()

    def className(self):
        r"""className(MomentTensorComponentContribution self) -> char const *"""
        return _datamodel.MomentTensorComponentContribution_className(self)

    def typeInfo(self):
        r"""typeInfo(MomentTensorComponentContribution self) -> RTTI"""
        return _datamodel.MomentTensorComponentContribution_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> MomentTensorComponentContribution
        Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorComponentContribution
        """
        return _datamodel.MomentTensorComponentContribution_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> MomentTensorComponentContribution
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorComponentContribution
        """
        return _datamodel.MomentTensorComponentContribution_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(MomentTensorComponentContribution self, GenericArchive ar)"""
        return _datamodel.MomentTensorComponentContribution_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.MomentTensorComponentContribution_Meta()

    def meta(self):
        r"""meta(MomentTensorComponentContribution self) -> MetaObject"""
        return _datamodel.MomentTensorComponentContribution_meta(self)

    def __init__(self, *args):
        r"""
        __init__(MomentTensorComponentContribution self) -> MomentTensorComponentContribution
        __init__(MomentTensorComponentContribution self, MomentTensorComponentContribution other) -> MomentTensorComponentContribution
        __init__(MomentTensorComponentContribution self, std::string const & phaseCode) -> MomentTensorComponentContribution
        __init__(MomentTensorComponentContribution self, std::string const & phaseCode, int component, bool active, double weight, double timeShift, double dataTimeWindow, Seiscomp::Core::Optional< double >::Impl const & misfit=Unset, Seiscomp::Core::Optional< double >::Impl const & snr=Unset) -> MomentTensorComponentContribution
        """
        _datamodel.MomentTensorComponentContribution_swiginit(self, _datamodel.new_MomentTensorComponentContribution(*args))
    __swig_destroy__ = _datamodel.delete_MomentTensorComponentContribution

    def __eq__(self, other):
        r"""__eq__(MomentTensorComponentContribution self, MomentTensorComponentContribution other) -> bool"""
        return _datamodel.MomentTensorComponentContribution___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(MomentTensorComponentContribution self, MomentTensorComponentContribution other) -> bool"""
        return _datamodel.MomentTensorComponentContribution___ne__(self, other)

    def equal(self, other):
        r"""equal(MomentTensorComponentContribution self, MomentTensorComponentContribution other) -> bool"""
        return _datamodel.MomentTensorComponentContribution_equal(self, other)

    def setPhaseCode(self, phaseCode):
        r"""setPhaseCode(MomentTensorComponentContribution self, std::string const & phaseCode)"""
        return _datamodel.MomentTensorComponentContribution_setPhaseCode(self, phaseCode)

    def phaseCode(self):
        r"""phaseCode(MomentTensorComponentContribution self) -> std::string const &"""
        return _datamodel.MomentTensorComponentContribution_phaseCode(self)

    def setComponent(self, component):
        r"""setComponent(MomentTensorComponentContribution self, int component)"""
        return _datamodel.MomentTensorComponentContribution_setComponent(self, component)

    def component(self):
        r"""component(MomentTensorComponentContribution self) -> int"""
        return _datamodel.MomentTensorComponentContribution_component(self)

    def setActive(self, active):
        r"""setActive(MomentTensorComponentContribution self, bool active)"""
        return _datamodel.MomentTensorComponentContribution_setActive(self, active)

    def active(self):
        r"""active(MomentTensorComponentContribution self) -> bool"""
        return _datamodel.MomentTensorComponentContribution_active(self)

    def setWeight(self, weight):
        r"""setWeight(MomentTensorComponentContribution self, double weight)"""
        return _datamodel.MomentTensorComponentContribution_setWeight(self, weight)

    def weight(self):
        r"""weight(MomentTensorComponentContribution self) -> double"""
        return _datamodel.MomentTensorComponentContribution_weight(self)

    def setTimeShift(self, timeShift):
        r"""setTimeShift(MomentTensorComponentContribution self, double timeShift)"""
        return _datamodel.MomentTensorComponentContribution_setTimeShift(self, timeShift)

    def timeShift(self):
        r"""timeShift(MomentTensorComponentContribution self) -> double"""
        return _datamodel.MomentTensorComponentContribution_timeShift(self)

    def setDataTimeWindow(self, arg2):
        r"""setDataTimeWindow(MomentTensorComponentContribution self, vectord arg2)"""
        return _datamodel.MomentTensorComponentContribution_setDataTimeWindow(self, arg2)

    def dataTimeWindow(self, *args):
        r"""
        dataTimeWindow(MomentTensorComponentContribution self) -> vectord
        dataTimeWindow(MomentTensorComponentContribution self) -> vectord
        """
        return _datamodel.MomentTensorComponentContribution_dataTimeWindow(self, *args)

    def setMisfit(self, misfit):
        r"""setMisfit(MomentTensorComponentContribution self, Seiscomp::Core::Optional< double >::Impl const & misfit)"""
        return _datamodel.MomentTensorComponentContribution_setMisfit(self, misfit)

    def misfit(self):
        r"""misfit(MomentTensorComponentContribution self) -> double"""
        return _datamodel.MomentTensorComponentContribution_misfit(self)

    def setSnr(self, snr):
        r"""setSnr(MomentTensorComponentContribution self, Seiscomp::Core::Optional< double >::Impl const & snr)"""
        return _datamodel.MomentTensorComponentContribution_setSnr(self, snr)

    def snr(self):
        r"""snr(MomentTensorComponentContribution self) -> double"""
        return _datamodel.MomentTensorComponentContribution_snr(self)

    def index(self):
        r"""index(MomentTensorComponentContribution self) -> MomentTensorComponentContributionIndex"""
        return _datamodel.MomentTensorComponentContribution_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(MomentTensorComponentContribution self, MomentTensorComponentContribution lhs) -> bool"""
        return _datamodel.MomentTensorComponentContribution_equalIndex(self, lhs)

    def momentTensorStationContribution(self):
        r"""momentTensorStationContribution(MomentTensorComponentContribution self) -> MomentTensorStationContribution"""
        return _datamodel.MomentTensorComponentContribution_momentTensorStationContribution(self)

    def assign(self, other):
        r"""assign(MomentTensorComponentContribution self, Object other) -> bool"""
        return _datamodel.MomentTensorComponentContribution_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(MomentTensorComponentContribution self, PublicObject parent) -> bool"""
        return _datamodel.MomentTensorComponentContribution_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(MomentTensorComponentContribution self, PublicObject parent) -> bool"""
        return _datamodel.MomentTensorComponentContribution_detachFrom(self, parent)

    def detach(self):
        r"""detach(MomentTensorComponentContribution self) -> bool"""
        return _datamodel.MomentTensorComponentContribution_detach(self)

    def clone(self):
        r"""clone(MomentTensorComponentContribution self) -> Object"""
        return _datamodel.MomentTensorComponentContribution_clone(self)

    def accept(self, visitor):
        r"""accept(MomentTensorComponentContribution self, Visitor visitor)"""
        return _datamodel.MomentTensorComponentContribution_accept(self, visitor)

# Register MomentTensorComponentContribution in _datamodel:
_datamodel.MomentTensorComponentContribution_swigregister(MomentTensorComponentContribution)

def MomentTensorComponentContribution_ClassName():
    r"""MomentTensorComponentContribution_ClassName() -> char const *"""
    return _datamodel.MomentTensorComponentContribution_ClassName()

def MomentTensorComponentContribution_TypeInfo():
    r"""MomentTensorComponentContribution_TypeInfo() -> RTTI"""
    return _datamodel.MomentTensorComponentContribution_TypeInfo()

def MomentTensorComponentContribution_Cast(*args):
    r"""
    MomentTensorComponentContribution_Cast(BaseObject o) -> MomentTensorComponentContribution
    MomentTensorComponentContribution_Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorComponentContribution
    """
    return _datamodel.MomentTensorComponentContribution_Cast(*args)

def MomentTensorComponentContribution_ConstCast(*args):
    r"""
    MomentTensorComponentContribution_ConstCast(BaseObject o) -> MomentTensorComponentContribution
    MomentTensorComponentContribution_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorComponentContribution
    """
    return _datamodel.MomentTensorComponentContribution_ConstCast(*args)

def MomentTensorComponentContribution_Meta():
    r"""MomentTensorComponentContribution_Meta() -> MetaObject"""
    return _datamodel.MomentTensorComponentContribution_Meta()

class MomentTensorStationContribution(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::MomentTensorStationContribution 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 _datamodel.MomentTensorStationContribution_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.MomentTensorStationContribution_TypeInfo()

    def className(self):
        r"""className(MomentTensorStationContribution self) -> char const *"""
        return _datamodel.MomentTensorStationContribution_className(self)

    def typeInfo(self):
        r"""typeInfo(MomentTensorStationContribution self) -> RTTI"""
        return _datamodel.MomentTensorStationContribution_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> MomentTensorStationContribution
        Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorStationContribution
        """
        return _datamodel.MomentTensorStationContribution_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> MomentTensorStationContribution
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorStationContribution
        """
        return _datamodel.MomentTensorStationContribution_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(MomentTensorStationContribution self, GenericArchive ar)"""
        return _datamodel.MomentTensorStationContribution_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.MomentTensorStationContribution_Meta()

    def meta(self):
        r"""meta(MomentTensorStationContribution self) -> MetaObject"""
        return _datamodel.MomentTensorStationContribution_meta(self)

    def __init__(self, *args):
        r"""
        __init__(MomentTensorStationContribution self, MomentTensorStationContribution other) -> MomentTensorStationContribution
        __init__(MomentTensorStationContribution self, std::string const & publicID) -> MomentTensorStationContribution
        """
        _datamodel.MomentTensorStationContribution_swiginit(self, _datamodel.new_MomentTensorStationContribution(*args))
    __swig_destroy__ = _datamodel.delete_MomentTensorStationContribution

    @staticmethod
    def Create(*args):
        r"""
        Create() -> MomentTensorStationContribution
        Create(std::string const & publicID) -> MomentTensorStationContribution
        """
        return _datamodel.MomentTensorStationContribution_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> MomentTensorStationContribution"""
        return _datamodel.MomentTensorStationContribution_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(MomentTensorStationContribution self, MomentTensorStationContribution other) -> bool"""
        return _datamodel.MomentTensorStationContribution___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(MomentTensorStationContribution self, MomentTensorStationContribution other) -> bool"""
        return _datamodel.MomentTensorStationContribution___ne__(self, other)

    def equal(self, other):
        r"""equal(MomentTensorStationContribution self, MomentTensorStationContribution other) -> bool"""
        return _datamodel.MomentTensorStationContribution_equal(self, other)

    def setActive(self, active):
        r"""setActive(MomentTensorStationContribution self, bool active)"""
        return _datamodel.MomentTensorStationContribution_setActive(self, active)

    def active(self):
        r"""active(MomentTensorStationContribution self) -> bool"""
        return _datamodel.MomentTensorStationContribution_active(self)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(MomentTensorStationContribution self, Seiscomp::Core::Optional< Seiscomp::DataModel::WaveformStreamID >::Impl const & waveformID)"""
        return _datamodel.MomentTensorStationContribution_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(MomentTensorStationContribution self) -> WaveformStreamID
        waveformID(MomentTensorStationContribution self) -> WaveformStreamID
        """
        return _datamodel.MomentTensorStationContribution_waveformID(self, *args)

    def setWeight(self, weight):
        r"""setWeight(MomentTensorStationContribution self, Seiscomp::Core::Optional< double >::Impl const & weight)"""
        return _datamodel.MomentTensorStationContribution_setWeight(self, weight)

    def weight(self):
        r"""weight(MomentTensorStationContribution self) -> double"""
        return _datamodel.MomentTensorStationContribution_weight(self)

    def setTimeShift(self, timeShift):
        r"""setTimeShift(MomentTensorStationContribution self, Seiscomp::Core::Optional< double >::Impl const & timeShift)"""
        return _datamodel.MomentTensorStationContribution_setTimeShift(self, timeShift)

    def timeShift(self):
        r"""timeShift(MomentTensorStationContribution self) -> double"""
        return _datamodel.MomentTensorStationContribution_timeShift(self)

    def add(self, obj):
        r"""add(MomentTensorStationContribution self, MomentTensorComponentContribution obj) -> bool"""
        return _datamodel.MomentTensorStationContribution_add(self, obj)

    def remove(self, obj):
        r"""remove(MomentTensorStationContribution self, MomentTensorComponentContribution obj) -> bool"""
        return _datamodel.MomentTensorStationContribution_remove(self, obj)

    def removeMomentTensorComponentContribution(self, *args):
        r"""
        removeMomentTensorComponentContribution(MomentTensorStationContribution self, size_t i) -> bool
        removeMomentTensorComponentContribution(MomentTensorStationContribution self, MomentTensorComponentContributionIndex i) -> bool
        """
        return _datamodel.MomentTensorStationContribution_removeMomentTensorComponentContribution(self, *args)

    def momentTensorComponentContributionCount(self):
        r"""momentTensorComponentContributionCount(MomentTensorStationContribution self) -> size_t"""
        return _datamodel.MomentTensorStationContribution_momentTensorComponentContributionCount(self)

    def momentTensorComponentContribution(self, *args):
        r"""
        momentTensorComponentContribution(MomentTensorStationContribution self, size_t i) -> MomentTensorComponentContribution
        momentTensorComponentContribution(MomentTensorStationContribution self, MomentTensorComponentContributionIndex i) -> MomentTensorComponentContribution
        """
        return _datamodel.MomentTensorStationContribution_momentTensorComponentContribution(self, *args)

    def momentTensor(self):
        r"""momentTensor(MomentTensorStationContribution self) -> MomentTensor"""
        return _datamodel.MomentTensorStationContribution_momentTensor(self)

    def assign(self, other):
        r"""assign(MomentTensorStationContribution self, Object other) -> bool"""
        return _datamodel.MomentTensorStationContribution_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(MomentTensorStationContribution self, PublicObject parent) -> bool"""
        return _datamodel.MomentTensorStationContribution_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(MomentTensorStationContribution self, PublicObject parent) -> bool"""
        return _datamodel.MomentTensorStationContribution_detachFrom(self, parent)

    def detach(self):
        r"""detach(MomentTensorStationContribution self) -> bool"""
        return _datamodel.MomentTensorStationContribution_detach(self)

    def clone(self):
        r"""clone(MomentTensorStationContribution self) -> Object"""
        return _datamodel.MomentTensorStationContribution_clone(self)

    def updateChild(self, child):
        r"""updateChild(MomentTensorStationContribution self, Object child) -> bool"""
        return _datamodel.MomentTensorStationContribution_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(MomentTensorStationContribution self, Visitor visitor)"""
        return _datamodel.MomentTensorStationContribution_accept(self, visitor)

# Register MomentTensorStationContribution in _datamodel:
_datamodel.MomentTensorStationContribution_swigregister(MomentTensorStationContribution)

def MomentTensorStationContribution_ClassName():
    r"""MomentTensorStationContribution_ClassName() -> char const *"""
    return _datamodel.MomentTensorStationContribution_ClassName()

def MomentTensorStationContribution_TypeInfo():
    r"""MomentTensorStationContribution_TypeInfo() -> RTTI"""
    return _datamodel.MomentTensorStationContribution_TypeInfo()

def MomentTensorStationContribution_Cast(*args):
    r"""
    MomentTensorStationContribution_Cast(BaseObject o) -> MomentTensorStationContribution
    MomentTensorStationContribution_Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorStationContribution
    """
    return _datamodel.MomentTensorStationContribution_Cast(*args)

def MomentTensorStationContribution_ConstCast(*args):
    r"""
    MomentTensorStationContribution_ConstCast(BaseObject o) -> MomentTensorStationContribution
    MomentTensorStationContribution_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorStationContribution
    """
    return _datamodel.MomentTensorStationContribution_ConstCast(*args)

def MomentTensorStationContribution_Meta():
    r"""MomentTensorStationContribution_Meta() -> MetaObject"""
    return _datamodel.MomentTensorStationContribution_Meta()

def MomentTensorStationContribution_Create(*args):
    r"""
    MomentTensorStationContribution_Create() -> MomentTensorStationContribution
    MomentTensorStationContribution_Create(std::string const & publicID) -> MomentTensorStationContribution
    """
    return _datamodel.MomentTensorStationContribution_Create(*args)

def MomentTensorStationContribution_Find(publicID):
    r"""MomentTensorStationContribution_Find(std::string const & publicID) -> MomentTensorStationContribution"""
    return _datamodel.MomentTensorStationContribution_Find(publicID)

class MomentTensorPhaseSettingIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::MomentTensorPhaseSettingIndex 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__(MomentTensorPhaseSettingIndex self) -> MomentTensorPhaseSettingIndex
        __init__(MomentTensorPhaseSettingIndex self, std::string const & code) -> MomentTensorPhaseSettingIndex
        __init__(MomentTensorPhaseSettingIndex self, MomentTensorPhaseSettingIndex arg2) -> MomentTensorPhaseSettingIndex
        """
        _datamodel.MomentTensorPhaseSettingIndex_swiginit(self, _datamodel.new_MomentTensorPhaseSettingIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(MomentTensorPhaseSettingIndex self, MomentTensorPhaseSettingIndex arg2) -> bool"""
        return _datamodel.MomentTensorPhaseSettingIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(MomentTensorPhaseSettingIndex self, MomentTensorPhaseSettingIndex arg2) -> bool"""
        return _datamodel.MomentTensorPhaseSettingIndex___ne__(self, arg2)
    code = property(_datamodel.MomentTensorPhaseSettingIndex_code_get, _datamodel.MomentTensorPhaseSettingIndex_code_set, doc=r"""code : std::string""")
    __swig_destroy__ = _datamodel.delete_MomentTensorPhaseSettingIndex

# Register MomentTensorPhaseSettingIndex in _datamodel:
_datamodel.MomentTensorPhaseSettingIndex_swigregister(MomentTensorPhaseSettingIndex)

class MomentTensorPhaseSetting(Object):
    r"""Proxy of C++ Seiscomp::DataModel::MomentTensorPhaseSetting 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 _datamodel.MomentTensorPhaseSetting_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.MomentTensorPhaseSetting_TypeInfo()

    def className(self):
        r"""className(MomentTensorPhaseSetting self) -> char const *"""
        return _datamodel.MomentTensorPhaseSetting_className(self)

    def typeInfo(self):
        r"""typeInfo(MomentTensorPhaseSetting self) -> RTTI"""
        return _datamodel.MomentTensorPhaseSetting_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> MomentTensorPhaseSetting
        Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorPhaseSetting
        """
        return _datamodel.MomentTensorPhaseSetting_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> MomentTensorPhaseSetting
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorPhaseSetting
        """
        return _datamodel.MomentTensorPhaseSetting_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(MomentTensorPhaseSetting self, GenericArchive ar)"""
        return _datamodel.MomentTensorPhaseSetting_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.MomentTensorPhaseSetting_Meta()

    def meta(self):
        r"""meta(MomentTensorPhaseSetting self) -> MetaObject"""
        return _datamodel.MomentTensorPhaseSetting_meta(self)

    def __init__(self, *args):
        r"""
        __init__(MomentTensorPhaseSetting self) -> MomentTensorPhaseSetting
        __init__(MomentTensorPhaseSetting self, MomentTensorPhaseSetting other) -> MomentTensorPhaseSetting
        __init__(MomentTensorPhaseSetting self, std::string const & code) -> MomentTensorPhaseSetting
        __init__(MomentTensorPhaseSetting self, std::string const & code, double lowerPeriod, double upperPeriod, Seiscomp::Core::Optional< double >::Impl const & minimumSNR=Unset, Seiscomp::Core::Optional< double >::Impl const & maximumTimeShift=Unset) -> MomentTensorPhaseSetting
        """
        _datamodel.MomentTensorPhaseSetting_swiginit(self, _datamodel.new_MomentTensorPhaseSetting(*args))
    __swig_destroy__ = _datamodel.delete_MomentTensorPhaseSetting

    def __eq__(self, other):
        r"""__eq__(MomentTensorPhaseSetting self, MomentTensorPhaseSetting other) -> bool"""
        return _datamodel.MomentTensorPhaseSetting___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(MomentTensorPhaseSetting self, MomentTensorPhaseSetting other) -> bool"""
        return _datamodel.MomentTensorPhaseSetting___ne__(self, other)

    def equal(self, other):
        r"""equal(MomentTensorPhaseSetting self, MomentTensorPhaseSetting other) -> bool"""
        return _datamodel.MomentTensorPhaseSetting_equal(self, other)

    def setCode(self, code):
        r"""setCode(MomentTensorPhaseSetting self, std::string const & code)"""
        return _datamodel.MomentTensorPhaseSetting_setCode(self, code)

    def code(self):
        r"""code(MomentTensorPhaseSetting self) -> std::string const &"""
        return _datamodel.MomentTensorPhaseSetting_code(self)

    def setLowerPeriod(self, lowerPeriod):
        r"""setLowerPeriod(MomentTensorPhaseSetting self, double lowerPeriod)"""
        return _datamodel.MomentTensorPhaseSetting_setLowerPeriod(self, lowerPeriod)

    def lowerPeriod(self):
        r"""lowerPeriod(MomentTensorPhaseSetting self) -> double"""
        return _datamodel.MomentTensorPhaseSetting_lowerPeriod(self)

    def setUpperPeriod(self, upperPeriod):
        r"""setUpperPeriod(MomentTensorPhaseSetting self, double upperPeriod)"""
        return _datamodel.MomentTensorPhaseSetting_setUpperPeriod(self, upperPeriod)

    def upperPeriod(self):
        r"""upperPeriod(MomentTensorPhaseSetting self) -> double"""
        return _datamodel.MomentTensorPhaseSetting_upperPeriod(self)

    def setMinimumSNR(self, minimumSNR):
        r"""setMinimumSNR(MomentTensorPhaseSetting self, Seiscomp::Core::Optional< double >::Impl const & minimumSNR)"""
        return _datamodel.MomentTensorPhaseSetting_setMinimumSNR(self, minimumSNR)

    def minimumSNR(self):
        r"""minimumSNR(MomentTensorPhaseSetting self) -> double"""
        return _datamodel.MomentTensorPhaseSetting_minimumSNR(self)

    def setMaximumTimeShift(self, maximumTimeShift):
        r"""setMaximumTimeShift(MomentTensorPhaseSetting self, Seiscomp::Core::Optional< double >::Impl const & maximumTimeShift)"""
        return _datamodel.MomentTensorPhaseSetting_setMaximumTimeShift(self, maximumTimeShift)

    def maximumTimeShift(self):
        r"""maximumTimeShift(MomentTensorPhaseSetting self) -> double"""
        return _datamodel.MomentTensorPhaseSetting_maximumTimeShift(self)

    def index(self):
        r"""index(MomentTensorPhaseSetting self) -> MomentTensorPhaseSettingIndex"""
        return _datamodel.MomentTensorPhaseSetting_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(MomentTensorPhaseSetting self, MomentTensorPhaseSetting lhs) -> bool"""
        return _datamodel.MomentTensorPhaseSetting_equalIndex(self, lhs)

    def momentTensor(self):
        r"""momentTensor(MomentTensorPhaseSetting self) -> MomentTensor"""
        return _datamodel.MomentTensorPhaseSetting_momentTensor(self)

    def assign(self, other):
        r"""assign(MomentTensorPhaseSetting self, Object other) -> bool"""
        return _datamodel.MomentTensorPhaseSetting_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(MomentTensorPhaseSetting self, PublicObject parent) -> bool"""
        return _datamodel.MomentTensorPhaseSetting_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(MomentTensorPhaseSetting self, PublicObject parent) -> bool"""
        return _datamodel.MomentTensorPhaseSetting_detachFrom(self, parent)

    def detach(self):
        r"""detach(MomentTensorPhaseSetting self) -> bool"""
        return _datamodel.MomentTensorPhaseSetting_detach(self)

    def clone(self):
        r"""clone(MomentTensorPhaseSetting self) -> Object"""
        return _datamodel.MomentTensorPhaseSetting_clone(self)

    def accept(self, visitor):
        r"""accept(MomentTensorPhaseSetting self, Visitor visitor)"""
        return _datamodel.MomentTensorPhaseSetting_accept(self, visitor)

# Register MomentTensorPhaseSetting in _datamodel:
_datamodel.MomentTensorPhaseSetting_swigregister(MomentTensorPhaseSetting)

def MomentTensorPhaseSetting_ClassName():
    r"""MomentTensorPhaseSetting_ClassName() -> char const *"""
    return _datamodel.MomentTensorPhaseSetting_ClassName()

def MomentTensorPhaseSetting_TypeInfo():
    r"""MomentTensorPhaseSetting_TypeInfo() -> RTTI"""
    return _datamodel.MomentTensorPhaseSetting_TypeInfo()

def MomentTensorPhaseSetting_Cast(*args):
    r"""
    MomentTensorPhaseSetting_Cast(BaseObject o) -> MomentTensorPhaseSetting
    MomentTensorPhaseSetting_Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorPhaseSetting
    """
    return _datamodel.MomentTensorPhaseSetting_Cast(*args)

def MomentTensorPhaseSetting_ConstCast(*args):
    r"""
    MomentTensorPhaseSetting_ConstCast(BaseObject o) -> MomentTensorPhaseSetting
    MomentTensorPhaseSetting_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorPhaseSetting
    """
    return _datamodel.MomentTensorPhaseSetting_ConstCast(*args)

def MomentTensorPhaseSetting_Meta():
    r"""MomentTensorPhaseSetting_Meta() -> MetaObject"""
    return _datamodel.MomentTensorPhaseSetting_Meta()

class MomentTensor(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::MomentTensor 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 _datamodel.MomentTensor_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.MomentTensor_TypeInfo()

    def className(self):
        r"""className(MomentTensor self) -> char const *"""
        return _datamodel.MomentTensor_className(self)

    def typeInfo(self):
        r"""typeInfo(MomentTensor self) -> RTTI"""
        return _datamodel.MomentTensor_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> MomentTensor
        Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensor
        """
        return _datamodel.MomentTensor_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> MomentTensor
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensor
        """
        return _datamodel.MomentTensor_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(MomentTensor self, GenericArchive ar)"""
        return _datamodel.MomentTensor_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.MomentTensor_Meta()

    def meta(self):
        r"""meta(MomentTensor self) -> MetaObject"""
        return _datamodel.MomentTensor_meta(self)

    def __init__(self, *args):
        r"""
        __init__(MomentTensor self, MomentTensor other) -> MomentTensor
        __init__(MomentTensor self, std::string const & publicID) -> MomentTensor
        """
        _datamodel.MomentTensor_swiginit(self, _datamodel.new_MomentTensor(*args))
    __swig_destroy__ = _datamodel.delete_MomentTensor

    @staticmethod
    def Create(*args):
        r"""
        Create() -> MomentTensor
        Create(std::string const & publicID) -> MomentTensor
        """
        return _datamodel.MomentTensor_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> MomentTensor"""
        return _datamodel.MomentTensor_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(MomentTensor self, MomentTensor other) -> bool"""
        return _datamodel.MomentTensor___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(MomentTensor self, MomentTensor other) -> bool"""
        return _datamodel.MomentTensor___ne__(self, other)

    def equal(self, other):
        r"""equal(MomentTensor self, MomentTensor other) -> bool"""
        return _datamodel.MomentTensor_equal(self, other)

    def setDerivedOriginID(self, derivedOriginID):
        r"""setDerivedOriginID(MomentTensor self, std::string const & derivedOriginID)"""
        return _datamodel.MomentTensor_setDerivedOriginID(self, derivedOriginID)

    def derivedOriginID(self):
        r"""derivedOriginID(MomentTensor self) -> std::string const &"""
        return _datamodel.MomentTensor_derivedOriginID(self)

    def setMomentMagnitudeID(self, momentMagnitudeID):
        r"""setMomentMagnitudeID(MomentTensor self, std::string const & momentMagnitudeID)"""
        return _datamodel.MomentTensor_setMomentMagnitudeID(self, momentMagnitudeID)

    def momentMagnitudeID(self):
        r"""momentMagnitudeID(MomentTensor self) -> std::string const &"""
        return _datamodel.MomentTensor_momentMagnitudeID(self)

    def setScalarMoment(self, scalarMoment):
        r"""setScalarMoment(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & scalarMoment)"""
        return _datamodel.MomentTensor_setScalarMoment(self, scalarMoment)

    def scalarMoment(self, *args):
        r"""
        scalarMoment(MomentTensor self) -> RealQuantity
        scalarMoment(MomentTensor self) -> RealQuantity
        """
        return _datamodel.MomentTensor_scalarMoment(self, *args)

    def setTensor(self, tensor):
        r"""setTensor(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::Tensor >::Impl const & tensor)"""
        return _datamodel.MomentTensor_setTensor(self, tensor)

    def tensor(self, *args):
        r"""
        tensor(MomentTensor self) -> Tensor
        tensor(MomentTensor self) -> Tensor
        """
        return _datamodel.MomentTensor_tensor(self, *args)

    def setVariance(self, variance):
        r"""setVariance(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & variance)"""
        return _datamodel.MomentTensor_setVariance(self, variance)

    def variance(self):
        r"""variance(MomentTensor self) -> double"""
        return _datamodel.MomentTensor_variance(self)

    def setVarianceReduction(self, varianceReduction):
        r"""setVarianceReduction(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & varianceReduction)"""
        return _datamodel.MomentTensor_setVarianceReduction(self, varianceReduction)

    def varianceReduction(self):
        r"""varianceReduction(MomentTensor self) -> double"""
        return _datamodel.MomentTensor_varianceReduction(self)

    def setDoubleCouple(self, doubleCouple):
        r"""setDoubleCouple(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & doubleCouple)"""
        return _datamodel.MomentTensor_setDoubleCouple(self, doubleCouple)

    def doubleCouple(self):
        r"""doubleCouple(MomentTensor self) -> double"""
        return _datamodel.MomentTensor_doubleCouple(self)

    def setClvd(self, clvd):
        r"""setClvd(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & clvd)"""
        return _datamodel.MomentTensor_setClvd(self, clvd)

    def clvd(self):
        r"""clvd(MomentTensor self) -> double"""
        return _datamodel.MomentTensor_clvd(self)

    def setIso(self, iso):
        r"""setIso(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & iso)"""
        return _datamodel.MomentTensor_setIso(self, iso)

    def iso(self):
        r"""iso(MomentTensor self) -> double"""
        return _datamodel.MomentTensor_iso(self)

    def setGreensFunctionID(self, greensFunctionID):
        r"""setGreensFunctionID(MomentTensor self, std::string const & greensFunctionID)"""
        return _datamodel.MomentTensor_setGreensFunctionID(self, greensFunctionID)

    def greensFunctionID(self):
        r"""greensFunctionID(MomentTensor self) -> std::string const &"""
        return _datamodel.MomentTensor_greensFunctionID(self)

    def setFilterID(self, filterID):
        r"""setFilterID(MomentTensor self, std::string const & filterID)"""
        return _datamodel.MomentTensor_setFilterID(self, filterID)

    def filterID(self):
        r"""filterID(MomentTensor self) -> std::string const &"""
        return _datamodel.MomentTensor_filterID(self)

    def setSourceTimeFunction(self, sourceTimeFunction):
        r"""setSourceTimeFunction(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::SourceTimeFunction >::Impl const & sourceTimeFunction)"""
        return _datamodel.MomentTensor_setSourceTimeFunction(self, sourceTimeFunction)

    def sourceTimeFunction(self, *args):
        r"""
        sourceTimeFunction(MomentTensor self) -> SourceTimeFunction
        sourceTimeFunction(MomentTensor self) -> SourceTimeFunction
        """
        return _datamodel.MomentTensor_sourceTimeFunction(self, *args)

    def setMethodID(self, methodID):
        r"""setMethodID(MomentTensor self, std::string const & methodID)"""
        return _datamodel.MomentTensor_setMethodID(self, methodID)

    def methodID(self):
        r"""methodID(MomentTensor self) -> std::string const &"""
        return _datamodel.MomentTensor_methodID(self)

    def setMethod(self, method):
        r"""setMethod(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::MomentTensorMethod >::Impl const & method)"""
        return _datamodel.MomentTensor_setMethod(self, method)

    def method(self):
        r"""method(MomentTensor self) -> Seiscomp::DataModel::MomentTensorMethod"""
        return _datamodel.MomentTensor_method(self)

    def setStatus(self, status):
        r"""setStatus(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::MomentTensorStatus >::Impl const & status)"""
        return _datamodel.MomentTensor_setStatus(self, status)

    def status(self):
        r"""status(MomentTensor self) -> Seiscomp::DataModel::MomentTensorStatus"""
        return _datamodel.MomentTensor_status(self)

    def setCmtName(self, cmtName):
        r"""setCmtName(MomentTensor self, std::string const & cmtName)"""
        return _datamodel.MomentTensor_setCmtName(self, cmtName)

    def cmtName(self):
        r"""cmtName(MomentTensor self) -> std::string const &"""
        return _datamodel.MomentTensor_cmtName(self)

    def setCmtVersion(self, cmtVersion):
        r"""setCmtVersion(MomentTensor self, std::string const & cmtVersion)"""
        return _datamodel.MomentTensor_setCmtVersion(self, cmtVersion)

    def cmtVersion(self):
        r"""cmtVersion(MomentTensor self) -> std::string const &"""
        return _datamodel.MomentTensor_cmtVersion(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.MomentTensor_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(MomentTensor self) -> CreationInfo
        creationInfo(MomentTensor self) -> CreationInfo
        """
        return _datamodel.MomentTensor_creationInfo(self, *args)

    def add(self, *args):
        r"""
        add(MomentTensor self, Comment obj) -> bool
        add(MomentTensor self, DataUsed obj) -> bool
        add(MomentTensor self, MomentTensorPhaseSetting obj) -> bool
        add(MomentTensor self, MomentTensorStationContribution obj) -> bool
        """
        return _datamodel.MomentTensor_add(self, *args)

    def remove(self, *args):
        r"""
        remove(MomentTensor self, Comment obj) -> bool
        remove(MomentTensor self, DataUsed obj) -> bool
        remove(MomentTensor self, MomentTensorPhaseSetting obj) -> bool
        remove(MomentTensor self, MomentTensorStationContribution obj) -> bool
        """
        return _datamodel.MomentTensor_remove(self, *args)

    def removeComment(self, *args):
        r"""
        removeComment(MomentTensor self, size_t i) -> bool
        removeComment(MomentTensor self, CommentIndex i) -> bool
        """
        return _datamodel.MomentTensor_removeComment(self, *args)

    def removeDataUsed(self, i):
        r"""removeDataUsed(MomentTensor self, size_t i) -> bool"""
        return _datamodel.MomentTensor_removeDataUsed(self, i)

    def removeMomentTensorPhaseSetting(self, *args):
        r"""
        removeMomentTensorPhaseSetting(MomentTensor self, size_t i) -> bool
        removeMomentTensorPhaseSetting(MomentTensor self, MomentTensorPhaseSettingIndex i) -> bool
        """
        return _datamodel.MomentTensor_removeMomentTensorPhaseSetting(self, *args)

    def removeMomentTensorStationContribution(self, i):
        r"""removeMomentTensorStationContribution(MomentTensor self, size_t i) -> bool"""
        return _datamodel.MomentTensor_removeMomentTensorStationContribution(self, i)

    def commentCount(self):
        r"""commentCount(MomentTensor self) -> size_t"""
        return _datamodel.MomentTensor_commentCount(self)

    def dataUsedCount(self):
        r"""dataUsedCount(MomentTensor self) -> size_t"""
        return _datamodel.MomentTensor_dataUsedCount(self)

    def momentTensorPhaseSettingCount(self):
        r"""momentTensorPhaseSettingCount(MomentTensor self) -> size_t"""
        return _datamodel.MomentTensor_momentTensorPhaseSettingCount(self)

    def momentTensorStationContributionCount(self):
        r"""momentTensorStationContributionCount(MomentTensor self) -> size_t"""
        return _datamodel.MomentTensor_momentTensorStationContributionCount(self)

    def comment(self, *args):
        r"""
        comment(MomentTensor self, size_t i) -> Comment
        comment(MomentTensor self, CommentIndex i) -> Comment
        """
        return _datamodel.MomentTensor_comment(self, *args)

    def dataUsed(self, i):
        r"""dataUsed(MomentTensor self, size_t i) -> DataUsed"""
        return _datamodel.MomentTensor_dataUsed(self, i)

    def momentTensorPhaseSetting(self, *args):
        r"""
        momentTensorPhaseSetting(MomentTensor self, size_t i) -> MomentTensorPhaseSetting
        momentTensorPhaseSetting(MomentTensor self, MomentTensorPhaseSettingIndex i) -> MomentTensorPhaseSetting
        """
        return _datamodel.MomentTensor_momentTensorPhaseSetting(self, *args)

    def momentTensorStationContribution(self, i):
        r"""momentTensorStationContribution(MomentTensor self, size_t i) -> MomentTensorStationContribution"""
        return _datamodel.MomentTensor_momentTensorStationContribution(self, i)

    def findDataUsed(self, dataUsed):
        r"""findDataUsed(MomentTensor self, DataUsed dataUsed) -> DataUsed"""
        return _datamodel.MomentTensor_findDataUsed(self, dataUsed)

    def findMomentTensorStationContribution(self, publicID):
        r"""findMomentTensorStationContribution(MomentTensor self, std::string const & publicID) -> MomentTensorStationContribution"""
        return _datamodel.MomentTensor_findMomentTensorStationContribution(self, publicID)

    def focalMechanism(self):
        r"""focalMechanism(MomentTensor self) -> FocalMechanism"""
        return _datamodel.MomentTensor_focalMechanism(self)

    def assign(self, other):
        r"""assign(MomentTensor self, Object other) -> bool"""
        return _datamodel.MomentTensor_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(MomentTensor self, PublicObject parent) -> bool"""
        return _datamodel.MomentTensor_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(MomentTensor self, PublicObject parent) -> bool"""
        return _datamodel.MomentTensor_detachFrom(self, parent)

    def detach(self):
        r"""detach(MomentTensor self) -> bool"""
        return _datamodel.MomentTensor_detach(self)

    def clone(self):
        r"""clone(MomentTensor self) -> Object"""
        return _datamodel.MomentTensor_clone(self)

    def updateChild(self, child):
        r"""updateChild(MomentTensor self, Object child) -> bool"""
        return _datamodel.MomentTensor_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(MomentTensor self, Visitor visitor)"""
        return _datamodel.MomentTensor_accept(self, visitor)

# Register MomentTensor in _datamodel:
_datamodel.MomentTensor_swigregister(MomentTensor)

def MomentTensor_ClassName():
    r"""MomentTensor_ClassName() -> char const *"""
    return _datamodel.MomentTensor_ClassName()

def MomentTensor_TypeInfo():
    r"""MomentTensor_TypeInfo() -> RTTI"""
    return _datamodel.MomentTensor_TypeInfo()

def MomentTensor_Cast(*args):
    r"""
    MomentTensor_Cast(BaseObject o) -> MomentTensor
    MomentTensor_Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensor
    """
    return _datamodel.MomentTensor_Cast(*args)

def MomentTensor_ConstCast(*args):
    r"""
    MomentTensor_ConstCast(BaseObject o) -> MomentTensor
    MomentTensor_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensor
    """
    return _datamodel.MomentTensor_ConstCast(*args)

def MomentTensor_Meta():
    r"""MomentTensor_Meta() -> MetaObject"""
    return _datamodel.MomentTensor_Meta()

def MomentTensor_Create(*args):
    r"""
    MomentTensor_Create() -> MomentTensor
    MomentTensor_Create(std::string const & publicID) -> MomentTensor
    """
    return _datamodel.MomentTensor_Create(*args)

def MomentTensor_Find(publicID):
    r"""MomentTensor_Find(std::string const & publicID) -> MomentTensor"""
    return _datamodel.MomentTensor_Find(publicID)

class FocalMechanism(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::FocalMechanism 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 _datamodel.FocalMechanism_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.FocalMechanism_TypeInfo()

    def className(self):
        r"""className(FocalMechanism self) -> char const *"""
        return _datamodel.FocalMechanism_className(self)

    def typeInfo(self):
        r"""typeInfo(FocalMechanism self) -> RTTI"""
        return _datamodel.FocalMechanism_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> FocalMechanism
        Cast(Seiscomp::Core::BaseObjectPtr o) -> FocalMechanism
        """
        return _datamodel.FocalMechanism_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> FocalMechanism
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FocalMechanism
        """
        return _datamodel.FocalMechanism_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(FocalMechanism self, GenericArchive ar)"""
        return _datamodel.FocalMechanism_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.FocalMechanism_Meta()

    def meta(self):
        r"""meta(FocalMechanism self) -> MetaObject"""
        return _datamodel.FocalMechanism_meta(self)

    def __init__(self, *args):
        r"""
        __init__(FocalMechanism self, FocalMechanism other) -> FocalMechanism
        __init__(FocalMechanism self, std::string const & publicID) -> FocalMechanism
        """
        _datamodel.FocalMechanism_swiginit(self, _datamodel.new_FocalMechanism(*args))
    __swig_destroy__ = _datamodel.delete_FocalMechanism

    @staticmethod
    def Create(*args):
        r"""
        Create() -> FocalMechanism
        Create(std::string const & publicID) -> FocalMechanism
        """
        return _datamodel.FocalMechanism_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> FocalMechanism"""
        return _datamodel.FocalMechanism_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(FocalMechanism self, FocalMechanism other) -> bool"""
        return _datamodel.FocalMechanism___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(FocalMechanism self, FocalMechanism other) -> bool"""
        return _datamodel.FocalMechanism___ne__(self, other)

    def equal(self, other):
        r"""equal(FocalMechanism self, FocalMechanism other) -> bool"""
        return _datamodel.FocalMechanism_equal(self, other)

    def setTriggeringOriginID(self, triggeringOriginID):
        r"""setTriggeringOriginID(FocalMechanism self, std::string const & triggeringOriginID)"""
        return _datamodel.FocalMechanism_setTriggeringOriginID(self, triggeringOriginID)

    def triggeringOriginID(self):
        r"""triggeringOriginID(FocalMechanism self) -> std::string const &"""
        return _datamodel.FocalMechanism_triggeringOriginID(self)

    def setNodalPlanes(self, nodalPlanes):
        r"""setNodalPlanes(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::NodalPlanes >::Impl const & nodalPlanes)"""
        return _datamodel.FocalMechanism_setNodalPlanes(self, nodalPlanes)

    def nodalPlanes(self, *args):
        r"""
        nodalPlanes(FocalMechanism self) -> NodalPlanes
        nodalPlanes(FocalMechanism self) -> NodalPlanes
        """
        return _datamodel.FocalMechanism_nodalPlanes(self, *args)

    def setPrincipalAxes(self, principalAxes):
        r"""setPrincipalAxes(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::PrincipalAxes >::Impl const & principalAxes)"""
        return _datamodel.FocalMechanism_setPrincipalAxes(self, principalAxes)

    def principalAxes(self, *args):
        r"""
        principalAxes(FocalMechanism self) -> PrincipalAxes
        principalAxes(FocalMechanism self) -> PrincipalAxes
        """
        return _datamodel.FocalMechanism_principalAxes(self, *args)

    def setAzimuthalGap(self, azimuthalGap):
        r"""setAzimuthalGap(FocalMechanism self, Seiscomp::Core::Optional< double >::Impl const & azimuthalGap)"""
        return _datamodel.FocalMechanism_setAzimuthalGap(self, azimuthalGap)

    def azimuthalGap(self):
        r"""azimuthalGap(FocalMechanism self) -> double"""
        return _datamodel.FocalMechanism_azimuthalGap(self)

    def setStationPolarityCount(self, stationPolarityCount):
        r"""setStationPolarityCount(FocalMechanism self, Seiscomp::Core::Optional< int >::Impl const & stationPolarityCount)"""
        return _datamodel.FocalMechanism_setStationPolarityCount(self, stationPolarityCount)

    def stationPolarityCount(self):
        r"""stationPolarityCount(FocalMechanism self) -> int"""
        return _datamodel.FocalMechanism_stationPolarityCount(self)

    def setMisfit(self, misfit):
        r"""setMisfit(FocalMechanism self, Seiscomp::Core::Optional< double >::Impl const & misfit)"""
        return _datamodel.FocalMechanism_setMisfit(self, misfit)

    def misfit(self):
        r"""misfit(FocalMechanism self) -> double"""
        return _datamodel.FocalMechanism_misfit(self)

    def setStationDistributionRatio(self, stationDistributionRatio):
        r"""setStationDistributionRatio(FocalMechanism self, Seiscomp::Core::Optional< double >::Impl const & stationDistributionRatio)"""
        return _datamodel.FocalMechanism_setStationDistributionRatio(self, stationDistributionRatio)

    def stationDistributionRatio(self):
        r"""stationDistributionRatio(FocalMechanism self) -> double"""
        return _datamodel.FocalMechanism_stationDistributionRatio(self)

    def setMethodID(self, methodID):
        r"""setMethodID(FocalMechanism self, std::string const & methodID)"""
        return _datamodel.FocalMechanism_setMethodID(self, methodID)

    def methodID(self):
        r"""methodID(FocalMechanism self) -> std::string const &"""
        return _datamodel.FocalMechanism_methodID(self)

    def setEvaluationMode(self, evaluationMode):
        r"""setEvaluationMode(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationMode >::Impl const & evaluationMode)"""
        return _datamodel.FocalMechanism_setEvaluationMode(self, evaluationMode)

    def evaluationMode(self):
        r"""evaluationMode(FocalMechanism self) -> Seiscomp::DataModel::EvaluationMode"""
        return _datamodel.FocalMechanism_evaluationMode(self)

    def setEvaluationStatus(self, evaluationStatus):
        r"""setEvaluationStatus(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationStatus >::Impl const & evaluationStatus)"""
        return _datamodel.FocalMechanism_setEvaluationStatus(self, evaluationStatus)

    def evaluationStatus(self):
        r"""evaluationStatus(FocalMechanism self) -> Seiscomp::DataModel::EvaluationStatus"""
        return _datamodel.FocalMechanism_evaluationStatus(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.FocalMechanism_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(FocalMechanism self) -> CreationInfo
        creationInfo(FocalMechanism self) -> CreationInfo
        """
        return _datamodel.FocalMechanism_creationInfo(self, *args)

    def add(self, *args):
        r"""
        add(FocalMechanism self, Comment obj) -> bool
        add(FocalMechanism self, MomentTensor obj) -> bool
        """
        return _datamodel.FocalMechanism_add(self, *args)

    def remove(self, *args):
        r"""
        remove(FocalMechanism self, Comment obj) -> bool
        remove(FocalMechanism self, MomentTensor obj) -> bool
        """
        return _datamodel.FocalMechanism_remove(self, *args)

    def removeComment(self, *args):
        r"""
        removeComment(FocalMechanism self, size_t i) -> bool
        removeComment(FocalMechanism self, CommentIndex i) -> bool
        """
        return _datamodel.FocalMechanism_removeComment(self, *args)

    def removeMomentTensor(self, i):
        r"""removeMomentTensor(FocalMechanism self, size_t i) -> bool"""
        return _datamodel.FocalMechanism_removeMomentTensor(self, i)

    def commentCount(self):
        r"""commentCount(FocalMechanism self) -> size_t"""
        return _datamodel.FocalMechanism_commentCount(self)

    def momentTensorCount(self):
        r"""momentTensorCount(FocalMechanism self) -> size_t"""
        return _datamodel.FocalMechanism_momentTensorCount(self)

    def comment(self, *args):
        r"""
        comment(FocalMechanism self, size_t i) -> Comment
        comment(FocalMechanism self, CommentIndex i) -> Comment
        """
        return _datamodel.FocalMechanism_comment(self, *args)

    def momentTensor(self, i):
        r"""momentTensor(FocalMechanism self, size_t i) -> MomentTensor"""
        return _datamodel.FocalMechanism_momentTensor(self, i)

    def findMomentTensor(self, publicID):
        r"""findMomentTensor(FocalMechanism self, std::string const & publicID) -> MomentTensor"""
        return _datamodel.FocalMechanism_findMomentTensor(self, publicID)

    def eventParameters(self):
        r"""eventParameters(FocalMechanism self) -> EventParameters"""
        return _datamodel.FocalMechanism_eventParameters(self)

    def assign(self, other):
        r"""assign(FocalMechanism self, Object other) -> bool"""
        return _datamodel.FocalMechanism_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(FocalMechanism self, PublicObject parent) -> bool"""
        return _datamodel.FocalMechanism_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(FocalMechanism self, PublicObject parent) -> bool"""
        return _datamodel.FocalMechanism_detachFrom(self, parent)

    def detach(self):
        r"""detach(FocalMechanism self) -> bool"""
        return _datamodel.FocalMechanism_detach(self)

    def clone(self):
        r"""clone(FocalMechanism self) -> Object"""
        return _datamodel.FocalMechanism_clone(self)

    def updateChild(self, child):
        r"""updateChild(FocalMechanism self, Object child) -> bool"""
        return _datamodel.FocalMechanism_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(FocalMechanism self, Visitor visitor)"""
        return _datamodel.FocalMechanism_accept(self, visitor)

# Register FocalMechanism in _datamodel:
_datamodel.FocalMechanism_swigregister(FocalMechanism)

def FocalMechanism_ClassName():
    r"""FocalMechanism_ClassName() -> char const *"""
    return _datamodel.FocalMechanism_ClassName()

def FocalMechanism_TypeInfo():
    r"""FocalMechanism_TypeInfo() -> RTTI"""
    return _datamodel.FocalMechanism_TypeInfo()

def FocalMechanism_Cast(*args):
    r"""
    FocalMechanism_Cast(BaseObject o) -> FocalMechanism
    FocalMechanism_Cast(Seiscomp::Core::BaseObjectPtr o) -> FocalMechanism
    """
    return _datamodel.FocalMechanism_Cast(*args)

def FocalMechanism_ConstCast(*args):
    r"""
    FocalMechanism_ConstCast(BaseObject o) -> FocalMechanism
    FocalMechanism_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FocalMechanism
    """
    return _datamodel.FocalMechanism_ConstCast(*args)

def FocalMechanism_Meta():
    r"""FocalMechanism_Meta() -> MetaObject"""
    return _datamodel.FocalMechanism_Meta()

def FocalMechanism_Create(*args):
    r"""
    FocalMechanism_Create() -> FocalMechanism
    FocalMechanism_Create(std::string const & publicID) -> FocalMechanism
    """
    return _datamodel.FocalMechanism_Create(*args)

def FocalMechanism_Find(publicID):
    r"""FocalMechanism_Find(std::string const & publicID) -> FocalMechanism"""
    return _datamodel.FocalMechanism_Find(publicID)

class Amplitude(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Amplitude 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 _datamodel.Amplitude_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Amplitude_TypeInfo()

    def className(self):
        r"""className(Amplitude self) -> char const *"""
        return _datamodel.Amplitude_className(self)

    def typeInfo(self):
        r"""typeInfo(Amplitude self) -> RTTI"""
        return _datamodel.Amplitude_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Amplitude
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Amplitude
        """
        return _datamodel.Amplitude_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Amplitude
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Amplitude
        """
        return _datamodel.Amplitude_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Amplitude self, GenericArchive ar)"""
        return _datamodel.Amplitude_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Amplitude_Meta()

    def meta(self):
        r"""meta(Amplitude self) -> MetaObject"""
        return _datamodel.Amplitude_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Amplitude self, Amplitude other) -> Amplitude
        __init__(Amplitude self, std::string const & publicID) -> Amplitude
        """
        _datamodel.Amplitude_swiginit(self, _datamodel.new_Amplitude(*args))
    __swig_destroy__ = _datamodel.delete_Amplitude

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Amplitude
        Create(std::string const & publicID) -> Amplitude
        """
        return _datamodel.Amplitude_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Amplitude"""
        return _datamodel.Amplitude_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Amplitude self, Amplitude other) -> bool"""
        return _datamodel.Amplitude___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Amplitude self, Amplitude other) -> bool"""
        return _datamodel.Amplitude___ne__(self, other)

    def equal(self, other):
        r"""equal(Amplitude self, Amplitude other) -> bool"""
        return _datamodel.Amplitude_equal(self, other)

    def setType(self, type):
        r"""setType(Amplitude self, std::string const & type)"""
        return _datamodel.Amplitude_setType(self, type)

    def type(self):
        r"""type(Amplitude self) -> std::string const &"""
        return _datamodel.Amplitude_type(self)

    def setAmplitude(self, amplitude):
        r"""setAmplitude(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & amplitude)"""
        return _datamodel.Amplitude_setAmplitude(self, amplitude)

    def amplitude(self, *args):
        r"""
        amplitude(Amplitude self) -> RealQuantity
        amplitude(Amplitude self) -> RealQuantity
        """
        return _datamodel.Amplitude_amplitude(self, *args)

    def setTimeWindow(self, timeWindow):
        r"""setTimeWindow(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::TimeWindow >::Impl const & timeWindow)"""
        return _datamodel.Amplitude_setTimeWindow(self, timeWindow)

    def timeWindow(self, *args):
        r"""
        timeWindow(Amplitude self) -> TimeWindow
        timeWindow(Amplitude self) -> TimeWindow
        """
        return _datamodel.Amplitude_timeWindow(self, *args)

    def setPeriod(self, period):
        r"""setPeriod(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & period)"""
        return _datamodel.Amplitude_setPeriod(self, period)

    def period(self, *args):
        r"""
        period(Amplitude self) -> RealQuantity
        period(Amplitude self) -> RealQuantity
        """
        return _datamodel.Amplitude_period(self, *args)

    def setSnr(self, snr):
        r"""setSnr(Amplitude self, Seiscomp::Core::Optional< double >::Impl const & snr)"""
        return _datamodel.Amplitude_setSnr(self, snr)

    def snr(self):
        r"""snr(Amplitude self) -> double"""
        return _datamodel.Amplitude_snr(self)

    def setUnit(self, unit):
        r"""setUnit(Amplitude self, std::string const & unit)"""
        return _datamodel.Amplitude_setUnit(self, unit)

    def unit(self):
        r"""unit(Amplitude self) -> std::string const &"""
        return _datamodel.Amplitude_unit(self)

    def setPickID(self, pickID):
        r"""setPickID(Amplitude self, std::string const & pickID)"""
        return _datamodel.Amplitude_setPickID(self, pickID)

    def pickID(self):
        r"""pickID(Amplitude self) -> std::string const &"""
        return _datamodel.Amplitude_pickID(self)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::WaveformStreamID >::Impl const & waveformID)"""
        return _datamodel.Amplitude_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(Amplitude self) -> WaveformStreamID
        waveformID(Amplitude self) -> WaveformStreamID
        """
        return _datamodel.Amplitude_waveformID(self, *args)

    def setFilterID(self, filterID):
        r"""setFilterID(Amplitude self, std::string const & filterID)"""
        return _datamodel.Amplitude_setFilterID(self, filterID)

    def filterID(self):
        r"""filterID(Amplitude self) -> std::string const &"""
        return _datamodel.Amplitude_filterID(self)

    def setMethodID(self, methodID):
        r"""setMethodID(Amplitude self, std::string const & methodID)"""
        return _datamodel.Amplitude_setMethodID(self, methodID)

    def methodID(self):
        r"""methodID(Amplitude self) -> std::string const &"""
        return _datamodel.Amplitude_methodID(self)

    def setScalingTime(self, scalingTime):
        r"""setScalingTime(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::TimeQuantity >::Impl const & scalingTime)"""
        return _datamodel.Amplitude_setScalingTime(self, scalingTime)

    def scalingTime(self, *args):
        r"""
        scalingTime(Amplitude self) -> TimeQuantity
        scalingTime(Amplitude self) -> TimeQuantity
        """
        return _datamodel.Amplitude_scalingTime(self, *args)

    def setMagnitudeHint(self, magnitudeHint):
        r"""setMagnitudeHint(Amplitude self, std::string const & magnitudeHint)"""
        return _datamodel.Amplitude_setMagnitudeHint(self, magnitudeHint)

    def magnitudeHint(self):
        r"""magnitudeHint(Amplitude self) -> std::string const &"""
        return _datamodel.Amplitude_magnitudeHint(self)

    def setEvaluationMode(self, evaluationMode):
        r"""setEvaluationMode(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationMode >::Impl const & evaluationMode)"""
        return _datamodel.Amplitude_setEvaluationMode(self, evaluationMode)

    def evaluationMode(self):
        r"""evaluationMode(Amplitude self) -> Seiscomp::DataModel::EvaluationMode"""
        return _datamodel.Amplitude_evaluationMode(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.Amplitude_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(Amplitude self) -> CreationInfo
        creationInfo(Amplitude self) -> CreationInfo
        """
        return _datamodel.Amplitude_creationInfo(self, *args)

    def add(self, obj):
        r"""add(Amplitude self, Comment obj) -> bool"""
        return _datamodel.Amplitude_add(self, obj)

    def remove(self, obj):
        r"""remove(Amplitude self, Comment obj) -> bool"""
        return _datamodel.Amplitude_remove(self, obj)

    def removeComment(self, *args):
        r"""
        removeComment(Amplitude self, size_t i) -> bool
        removeComment(Amplitude self, CommentIndex i) -> bool
        """
        return _datamodel.Amplitude_removeComment(self, *args)

    def commentCount(self):
        r"""commentCount(Amplitude self) -> size_t"""
        return _datamodel.Amplitude_commentCount(self)

    def comment(self, *args):
        r"""
        comment(Amplitude self, size_t i) -> Comment
        comment(Amplitude self, CommentIndex i) -> Comment
        """
        return _datamodel.Amplitude_comment(self, *args)

    def eventParameters(self):
        r"""eventParameters(Amplitude self) -> EventParameters"""
        return _datamodel.Amplitude_eventParameters(self)

    def assign(self, other):
        r"""assign(Amplitude self, Object other) -> bool"""
        return _datamodel.Amplitude_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Amplitude self, PublicObject parent) -> bool"""
        return _datamodel.Amplitude_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Amplitude self, PublicObject parent) -> bool"""
        return _datamodel.Amplitude_detachFrom(self, parent)

    def detach(self):
        r"""detach(Amplitude self) -> bool"""
        return _datamodel.Amplitude_detach(self)

    def clone(self):
        r"""clone(Amplitude self) -> Object"""
        return _datamodel.Amplitude_clone(self)

    def updateChild(self, child):
        r"""updateChild(Amplitude self, Object child) -> bool"""
        return _datamodel.Amplitude_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Amplitude self, Visitor visitor)"""
        return _datamodel.Amplitude_accept(self, visitor)

# Register Amplitude in _datamodel:
_datamodel.Amplitude_swigregister(Amplitude)

def Amplitude_ClassName():
    r"""Amplitude_ClassName() -> char const *"""
    return _datamodel.Amplitude_ClassName()

def Amplitude_TypeInfo():
    r"""Amplitude_TypeInfo() -> RTTI"""
    return _datamodel.Amplitude_TypeInfo()

def Amplitude_Cast(*args):
    r"""
    Amplitude_Cast(BaseObject o) -> Amplitude
    Amplitude_Cast(Seiscomp::Core::BaseObjectPtr o) -> Amplitude
    """
    return _datamodel.Amplitude_Cast(*args)

def Amplitude_ConstCast(*args):
    r"""
    Amplitude_ConstCast(BaseObject o) -> Amplitude
    Amplitude_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Amplitude
    """
    return _datamodel.Amplitude_ConstCast(*args)

def Amplitude_Meta():
    r"""Amplitude_Meta() -> MetaObject"""
    return _datamodel.Amplitude_Meta()

def Amplitude_Create(*args):
    r"""
    Amplitude_Create() -> Amplitude
    Amplitude_Create(std::string const & publicID) -> Amplitude
    """
    return _datamodel.Amplitude_Create(*args)

def Amplitude_Find(publicID):
    r"""Amplitude_Find(std::string const & publicID) -> Amplitude"""
    return _datamodel.Amplitude_Find(publicID)

class StationMagnitudeContributionIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::StationMagnitudeContributionIndex 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__(StationMagnitudeContributionIndex self) -> StationMagnitudeContributionIndex
        __init__(StationMagnitudeContributionIndex self, std::string const & stationMagnitudeID) -> StationMagnitudeContributionIndex
        __init__(StationMagnitudeContributionIndex self, StationMagnitudeContributionIndex arg2) -> StationMagnitudeContributionIndex
        """
        _datamodel.StationMagnitudeContributionIndex_swiginit(self, _datamodel.new_StationMagnitudeContributionIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(StationMagnitudeContributionIndex self, StationMagnitudeContributionIndex arg2) -> bool"""
        return _datamodel.StationMagnitudeContributionIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(StationMagnitudeContributionIndex self, StationMagnitudeContributionIndex arg2) -> bool"""
        return _datamodel.StationMagnitudeContributionIndex___ne__(self, arg2)
    stationMagnitudeID = property(_datamodel.StationMagnitudeContributionIndex_stationMagnitudeID_get, _datamodel.StationMagnitudeContributionIndex_stationMagnitudeID_set, doc=r"""stationMagnitudeID : std::string""")
    __swig_destroy__ = _datamodel.delete_StationMagnitudeContributionIndex

# Register StationMagnitudeContributionIndex in _datamodel:
_datamodel.StationMagnitudeContributionIndex_swigregister(StationMagnitudeContributionIndex)

class StationMagnitudeContribution(Object):
    r"""Proxy of C++ Seiscomp::DataModel::StationMagnitudeContribution 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 _datamodel.StationMagnitudeContribution_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.StationMagnitudeContribution_TypeInfo()

    def className(self):
        r"""className(StationMagnitudeContribution self) -> char const *"""
        return _datamodel.StationMagnitudeContribution_className(self)

    def typeInfo(self):
        r"""typeInfo(StationMagnitudeContribution self) -> RTTI"""
        return _datamodel.StationMagnitudeContribution_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> StationMagnitudeContribution
        Cast(Seiscomp::Core::BaseObjectPtr o) -> StationMagnitudeContribution
        """
        return _datamodel.StationMagnitudeContribution_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> StationMagnitudeContribution
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationMagnitudeContribution
        """
        return _datamodel.StationMagnitudeContribution_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(StationMagnitudeContribution self, GenericArchive ar)"""
        return _datamodel.StationMagnitudeContribution_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.StationMagnitudeContribution_Meta()

    def meta(self):
        r"""meta(StationMagnitudeContribution self) -> MetaObject"""
        return _datamodel.StationMagnitudeContribution_meta(self)

    def __init__(self, *args):
        r"""
        __init__(StationMagnitudeContribution self) -> StationMagnitudeContribution
        __init__(StationMagnitudeContribution self, StationMagnitudeContribution other) -> StationMagnitudeContribution
        __init__(StationMagnitudeContribution self, std::string const & stationMagnitudeID, Seiscomp::Core::Optional< double >::Impl const & residual=Unset, Seiscomp::Core::Optional< double >::Impl const & weight=Unset) -> StationMagnitudeContribution
        """
        _datamodel.StationMagnitudeContribution_swiginit(self, _datamodel.new_StationMagnitudeContribution(*args))
    __swig_destroy__ = _datamodel.delete_StationMagnitudeContribution

    def __eq__(self, other):
        r"""__eq__(StationMagnitudeContribution self, StationMagnitudeContribution other) -> bool"""
        return _datamodel.StationMagnitudeContribution___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(StationMagnitudeContribution self, StationMagnitudeContribution other) -> bool"""
        return _datamodel.StationMagnitudeContribution___ne__(self, other)

    def equal(self, other):
        r"""equal(StationMagnitudeContribution self, StationMagnitudeContribution other) -> bool"""
        return _datamodel.StationMagnitudeContribution_equal(self, other)

    def setStationMagnitudeID(self, stationMagnitudeID):
        r"""setStationMagnitudeID(StationMagnitudeContribution self, std::string const & stationMagnitudeID)"""
        return _datamodel.StationMagnitudeContribution_setStationMagnitudeID(self, stationMagnitudeID)

    def stationMagnitudeID(self):
        r"""stationMagnitudeID(StationMagnitudeContribution self) -> std::string const &"""
        return _datamodel.StationMagnitudeContribution_stationMagnitudeID(self)

    def setResidual(self, residual):
        r"""setResidual(StationMagnitudeContribution self, Seiscomp::Core::Optional< double >::Impl const & residual)"""
        return _datamodel.StationMagnitudeContribution_setResidual(self, residual)

    def residual(self):
        r"""residual(StationMagnitudeContribution self) -> double"""
        return _datamodel.StationMagnitudeContribution_residual(self)

    def setWeight(self, weight):
        r"""setWeight(StationMagnitudeContribution self, Seiscomp::Core::Optional< double >::Impl const & weight)"""
        return _datamodel.StationMagnitudeContribution_setWeight(self, weight)

    def weight(self):
        r"""weight(StationMagnitudeContribution self) -> double"""
        return _datamodel.StationMagnitudeContribution_weight(self)

    def index(self):
        r"""index(StationMagnitudeContribution self) -> StationMagnitudeContributionIndex"""
        return _datamodel.StationMagnitudeContribution_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(StationMagnitudeContribution self, StationMagnitudeContribution lhs) -> bool"""
        return _datamodel.StationMagnitudeContribution_equalIndex(self, lhs)

    def magnitude(self):
        r"""magnitude(StationMagnitudeContribution self) -> Magnitude"""
        return _datamodel.StationMagnitudeContribution_magnitude(self)

    def assign(self, other):
        r"""assign(StationMagnitudeContribution self, Object other) -> bool"""
        return _datamodel.StationMagnitudeContribution_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(StationMagnitudeContribution self, PublicObject parent) -> bool"""
        return _datamodel.StationMagnitudeContribution_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(StationMagnitudeContribution self, PublicObject parent) -> bool"""
        return _datamodel.StationMagnitudeContribution_detachFrom(self, parent)

    def detach(self):
        r"""detach(StationMagnitudeContribution self) -> bool"""
        return _datamodel.StationMagnitudeContribution_detach(self)

    def clone(self):
        r"""clone(StationMagnitudeContribution self) -> Object"""
        return _datamodel.StationMagnitudeContribution_clone(self)

    def accept(self, visitor):
        r"""accept(StationMagnitudeContribution self, Visitor visitor)"""
        return _datamodel.StationMagnitudeContribution_accept(self, visitor)

# Register StationMagnitudeContribution in _datamodel:
_datamodel.StationMagnitudeContribution_swigregister(StationMagnitudeContribution)

def StationMagnitudeContribution_ClassName():
    r"""StationMagnitudeContribution_ClassName() -> char const *"""
    return _datamodel.StationMagnitudeContribution_ClassName()

def StationMagnitudeContribution_TypeInfo():
    r"""StationMagnitudeContribution_TypeInfo() -> RTTI"""
    return _datamodel.StationMagnitudeContribution_TypeInfo()

def StationMagnitudeContribution_Cast(*args):
    r"""
    StationMagnitudeContribution_Cast(BaseObject o) -> StationMagnitudeContribution
    StationMagnitudeContribution_Cast(Seiscomp::Core::BaseObjectPtr o) -> StationMagnitudeContribution
    """
    return _datamodel.StationMagnitudeContribution_Cast(*args)

def StationMagnitudeContribution_ConstCast(*args):
    r"""
    StationMagnitudeContribution_ConstCast(BaseObject o) -> StationMagnitudeContribution
    StationMagnitudeContribution_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationMagnitudeContribution
    """
    return _datamodel.StationMagnitudeContribution_ConstCast(*args)

def StationMagnitudeContribution_Meta():
    r"""StationMagnitudeContribution_Meta() -> MetaObject"""
    return _datamodel.StationMagnitudeContribution_Meta()

class Magnitude(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Magnitude 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 _datamodel.Magnitude_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Magnitude_TypeInfo()

    def className(self):
        r"""className(Magnitude self) -> char const *"""
        return _datamodel.Magnitude_className(self)

    def typeInfo(self):
        r"""typeInfo(Magnitude self) -> RTTI"""
        return _datamodel.Magnitude_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Magnitude
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Magnitude
        """
        return _datamodel.Magnitude_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Magnitude
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Magnitude
        """
        return _datamodel.Magnitude_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Magnitude self, GenericArchive ar)"""
        return _datamodel.Magnitude_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Magnitude_Meta()

    def meta(self):
        r"""meta(Magnitude self) -> MetaObject"""
        return _datamodel.Magnitude_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Magnitude self, Magnitude other) -> Magnitude
        __init__(Magnitude self, std::string const & publicID) -> Magnitude
        """
        _datamodel.Magnitude_swiginit(self, _datamodel.new_Magnitude(*args))
    __swig_destroy__ = _datamodel.delete_Magnitude

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Magnitude
        Create(std::string const & publicID) -> Magnitude
        """
        return _datamodel.Magnitude_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Magnitude"""
        return _datamodel.Magnitude_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Magnitude self, Magnitude other) -> bool"""
        return _datamodel.Magnitude___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Magnitude self, Magnitude other) -> bool"""
        return _datamodel.Magnitude___ne__(self, other)

    def equal(self, other):
        r"""equal(Magnitude self, Magnitude other) -> bool"""
        return _datamodel.Magnitude_equal(self, other)

    def setMagnitude(self, magnitude):
        r"""setMagnitude(Magnitude self, RealQuantity magnitude)"""
        return _datamodel.Magnitude_setMagnitude(self, magnitude)

    def magnitude(self, *args):
        r"""
        magnitude(Magnitude self) -> RealQuantity
        magnitude(Magnitude self) -> RealQuantity
        """
        return _datamodel.Magnitude_magnitude(self, *args)

    def setType(self, type):
        r"""setType(Magnitude self, std::string const & type)"""
        return _datamodel.Magnitude_setType(self, type)

    def type(self):
        r"""type(Magnitude self) -> std::string const &"""
        return _datamodel.Magnitude_type(self)

    def setOriginID(self, originID):
        r"""setOriginID(Magnitude self, std::string const & originID)"""
        return _datamodel.Magnitude_setOriginID(self, originID)

    def originID(self):
        r"""originID(Magnitude self) -> std::string const &"""
        return _datamodel.Magnitude_originID(self)

    def setMethodID(self, methodID):
        r"""setMethodID(Magnitude self, std::string const & methodID)"""
        return _datamodel.Magnitude_setMethodID(self, methodID)

    def methodID(self):
        r"""methodID(Magnitude self) -> std::string const &"""
        return _datamodel.Magnitude_methodID(self)

    def setStationCount(self, stationCount):
        r"""setStationCount(Magnitude self, Seiscomp::Core::Optional< int >::Impl const & stationCount)"""
        return _datamodel.Magnitude_setStationCount(self, stationCount)

    def stationCount(self):
        r"""stationCount(Magnitude self) -> int"""
        return _datamodel.Magnitude_stationCount(self)

    def setAzimuthalGap(self, azimuthalGap):
        r"""setAzimuthalGap(Magnitude self, Seiscomp::Core::Optional< double >::Impl const & azimuthalGap)"""
        return _datamodel.Magnitude_setAzimuthalGap(self, azimuthalGap)

    def azimuthalGap(self):
        r"""azimuthalGap(Magnitude self) -> double"""
        return _datamodel.Magnitude_azimuthalGap(self)

    def setEvaluationStatus(self, evaluationStatus):
        r"""setEvaluationStatus(Magnitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationStatus >::Impl const & evaluationStatus)"""
        return _datamodel.Magnitude_setEvaluationStatus(self, evaluationStatus)

    def evaluationStatus(self):
        r"""evaluationStatus(Magnitude self) -> Seiscomp::DataModel::EvaluationStatus"""
        return _datamodel.Magnitude_evaluationStatus(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(Magnitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.Magnitude_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(Magnitude self) -> CreationInfo
        creationInfo(Magnitude self) -> CreationInfo
        """
        return _datamodel.Magnitude_creationInfo(self, *args)

    def add(self, *args):
        r"""
        add(Magnitude self, Comment obj) -> bool
        add(Magnitude self, StationMagnitudeContribution obj) -> bool
        """
        return _datamodel.Magnitude_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Magnitude self, Comment obj) -> bool
        remove(Magnitude self, StationMagnitudeContribution obj) -> bool
        """
        return _datamodel.Magnitude_remove(self, *args)

    def removeComment(self, *args):
        r"""
        removeComment(Magnitude self, size_t i) -> bool
        removeComment(Magnitude self, CommentIndex i) -> bool
        """
        return _datamodel.Magnitude_removeComment(self, *args)

    def removeStationMagnitudeContribution(self, *args):
        r"""
        removeStationMagnitudeContribution(Magnitude self, size_t i) -> bool
        removeStationMagnitudeContribution(Magnitude self, StationMagnitudeContributionIndex i) -> bool
        """
        return _datamodel.Magnitude_removeStationMagnitudeContribution(self, *args)

    def commentCount(self):
        r"""commentCount(Magnitude self) -> size_t"""
        return _datamodel.Magnitude_commentCount(self)

    def stationMagnitudeContributionCount(self):
        r"""stationMagnitudeContributionCount(Magnitude self) -> size_t"""
        return _datamodel.Magnitude_stationMagnitudeContributionCount(self)

    def comment(self, *args):
        r"""
        comment(Magnitude self, size_t i) -> Comment
        comment(Magnitude self, CommentIndex i) -> Comment
        """
        return _datamodel.Magnitude_comment(self, *args)

    def stationMagnitudeContribution(self, *args):
        r"""
        stationMagnitudeContribution(Magnitude self, size_t i) -> StationMagnitudeContribution
        stationMagnitudeContribution(Magnitude self, StationMagnitudeContributionIndex i) -> StationMagnitudeContribution
        """
        return _datamodel.Magnitude_stationMagnitudeContribution(self, *args)

    def origin(self):
        r"""origin(Magnitude self) -> Origin"""
        return _datamodel.Magnitude_origin(self)

    def assign(self, other):
        r"""assign(Magnitude self, Object other) -> bool"""
        return _datamodel.Magnitude_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Magnitude self, PublicObject parent) -> bool"""
        return _datamodel.Magnitude_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Magnitude self, PublicObject parent) -> bool"""
        return _datamodel.Magnitude_detachFrom(self, parent)

    def detach(self):
        r"""detach(Magnitude self) -> bool"""
        return _datamodel.Magnitude_detach(self)

    def clone(self):
        r"""clone(Magnitude self) -> Object"""
        return _datamodel.Magnitude_clone(self)

    def updateChild(self, child):
        r"""updateChild(Magnitude self, Object child) -> bool"""
        return _datamodel.Magnitude_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Magnitude self, Visitor visitor)"""
        return _datamodel.Magnitude_accept(self, visitor)

# Register Magnitude in _datamodel:
_datamodel.Magnitude_swigregister(Magnitude)

def Magnitude_ClassName():
    r"""Magnitude_ClassName() -> char const *"""
    return _datamodel.Magnitude_ClassName()

def Magnitude_TypeInfo():
    r"""Magnitude_TypeInfo() -> RTTI"""
    return _datamodel.Magnitude_TypeInfo()

def Magnitude_Cast(*args):
    r"""
    Magnitude_Cast(BaseObject o) -> Magnitude
    Magnitude_Cast(Seiscomp::Core::BaseObjectPtr o) -> Magnitude
    """
    return _datamodel.Magnitude_Cast(*args)

def Magnitude_ConstCast(*args):
    r"""
    Magnitude_ConstCast(BaseObject o) -> Magnitude
    Magnitude_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Magnitude
    """
    return _datamodel.Magnitude_ConstCast(*args)

def Magnitude_Meta():
    r"""Magnitude_Meta() -> MetaObject"""
    return _datamodel.Magnitude_Meta()

def Magnitude_Create(*args):
    r"""
    Magnitude_Create() -> Magnitude
    Magnitude_Create(std::string const & publicID) -> Magnitude
    """
    return _datamodel.Magnitude_Create(*args)

def Magnitude_Find(publicID):
    r"""Magnitude_Find(std::string const & publicID) -> Magnitude"""
    return _datamodel.Magnitude_Find(publicID)

class StationMagnitude(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::StationMagnitude 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 _datamodel.StationMagnitude_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.StationMagnitude_TypeInfo()

    def className(self):
        r"""className(StationMagnitude self) -> char const *"""
        return _datamodel.StationMagnitude_className(self)

    def typeInfo(self):
        r"""typeInfo(StationMagnitude self) -> RTTI"""
        return _datamodel.StationMagnitude_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> StationMagnitude
        Cast(Seiscomp::Core::BaseObjectPtr o) -> StationMagnitude
        """
        return _datamodel.StationMagnitude_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> StationMagnitude
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationMagnitude
        """
        return _datamodel.StationMagnitude_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(StationMagnitude self, GenericArchive ar)"""
        return _datamodel.StationMagnitude_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.StationMagnitude_Meta()

    def meta(self):
        r"""meta(StationMagnitude self) -> MetaObject"""
        return _datamodel.StationMagnitude_meta(self)

    def __init__(self, *args):
        r"""
        __init__(StationMagnitude self, StationMagnitude other) -> StationMagnitude
        __init__(StationMagnitude self, std::string const & publicID) -> StationMagnitude
        """
        _datamodel.StationMagnitude_swiginit(self, _datamodel.new_StationMagnitude(*args))
    __swig_destroy__ = _datamodel.delete_StationMagnitude

    @staticmethod
    def Create(*args):
        r"""
        Create() -> StationMagnitude
        Create(std::string const & publicID) -> StationMagnitude
        """
        return _datamodel.StationMagnitude_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> StationMagnitude"""
        return _datamodel.StationMagnitude_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(StationMagnitude self, StationMagnitude other) -> bool"""
        return _datamodel.StationMagnitude___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(StationMagnitude self, StationMagnitude other) -> bool"""
        return _datamodel.StationMagnitude___ne__(self, other)

    def equal(self, other):
        r"""equal(StationMagnitude self, StationMagnitude other) -> bool"""
        return _datamodel.StationMagnitude_equal(self, other)

    def setOriginID(self, originID):
        r"""setOriginID(StationMagnitude self, std::string const & originID)"""
        return _datamodel.StationMagnitude_setOriginID(self, originID)

    def originID(self):
        r"""originID(StationMagnitude self) -> std::string const &"""
        return _datamodel.StationMagnitude_originID(self)

    def setMagnitude(self, magnitude):
        r"""setMagnitude(StationMagnitude self, RealQuantity magnitude)"""
        return _datamodel.StationMagnitude_setMagnitude(self, magnitude)

    def magnitude(self, *args):
        r"""
        magnitude(StationMagnitude self) -> RealQuantity
        magnitude(StationMagnitude self) -> RealQuantity
        """
        return _datamodel.StationMagnitude_magnitude(self, *args)

    def setType(self, type):
        r"""setType(StationMagnitude self, std::string const & type)"""
        return _datamodel.StationMagnitude_setType(self, type)

    def type(self):
        r"""type(StationMagnitude self) -> std::string const &"""
        return _datamodel.StationMagnitude_type(self)

    def setAmplitudeID(self, amplitudeID):
        r"""setAmplitudeID(StationMagnitude self, std::string const & amplitudeID)"""
        return _datamodel.StationMagnitude_setAmplitudeID(self, amplitudeID)

    def amplitudeID(self):
        r"""amplitudeID(StationMagnitude self) -> std::string const &"""
        return _datamodel.StationMagnitude_amplitudeID(self)

    def setMethodID(self, methodID):
        r"""setMethodID(StationMagnitude self, std::string const & methodID)"""
        return _datamodel.StationMagnitude_setMethodID(self, methodID)

    def methodID(self):
        r"""methodID(StationMagnitude self) -> std::string const &"""
        return _datamodel.StationMagnitude_methodID(self)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(StationMagnitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::WaveformStreamID >::Impl const & waveformID)"""
        return _datamodel.StationMagnitude_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(StationMagnitude self) -> WaveformStreamID
        waveformID(StationMagnitude self) -> WaveformStreamID
        """
        return _datamodel.StationMagnitude_waveformID(self, *args)

    def setPassedQC(self, passedQC):
        r"""setPassedQC(StationMagnitude self, Seiscomp::Core::Optional< bool >::Impl const & passedQC)"""
        return _datamodel.StationMagnitude_setPassedQC(self, passedQC)

    def passedQC(self):
        r"""passedQC(StationMagnitude self) -> bool"""
        return _datamodel.StationMagnitude_passedQC(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(StationMagnitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.StationMagnitude_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(StationMagnitude self) -> CreationInfo
        creationInfo(StationMagnitude self) -> CreationInfo
        """
        return _datamodel.StationMagnitude_creationInfo(self, *args)

    def add(self, obj):
        r"""add(StationMagnitude self, Comment obj) -> bool"""
        return _datamodel.StationMagnitude_add(self, obj)

    def remove(self, obj):
        r"""remove(StationMagnitude self, Comment obj) -> bool"""
        return _datamodel.StationMagnitude_remove(self, obj)

    def removeComment(self, *args):
        r"""
        removeComment(StationMagnitude self, size_t i) -> bool
        removeComment(StationMagnitude self, CommentIndex i) -> bool
        """
        return _datamodel.StationMagnitude_removeComment(self, *args)

    def commentCount(self):
        r"""commentCount(StationMagnitude self) -> size_t"""
        return _datamodel.StationMagnitude_commentCount(self)

    def comment(self, *args):
        r"""
        comment(StationMagnitude self, size_t i) -> Comment
        comment(StationMagnitude self, CommentIndex i) -> Comment
        """
        return _datamodel.StationMagnitude_comment(self, *args)

    def origin(self):
        r"""origin(StationMagnitude self) -> Origin"""
        return _datamodel.StationMagnitude_origin(self)

    def assign(self, other):
        r"""assign(StationMagnitude self, Object other) -> bool"""
        return _datamodel.StationMagnitude_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(StationMagnitude self, PublicObject parent) -> bool"""
        return _datamodel.StationMagnitude_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(StationMagnitude self, PublicObject parent) -> bool"""
        return _datamodel.StationMagnitude_detachFrom(self, parent)

    def detach(self):
        r"""detach(StationMagnitude self) -> bool"""
        return _datamodel.StationMagnitude_detach(self)

    def clone(self):
        r"""clone(StationMagnitude self) -> Object"""
        return _datamodel.StationMagnitude_clone(self)

    def updateChild(self, child):
        r"""updateChild(StationMagnitude self, Object child) -> bool"""
        return _datamodel.StationMagnitude_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(StationMagnitude self, Visitor visitor)"""
        return _datamodel.StationMagnitude_accept(self, visitor)

# Register StationMagnitude in _datamodel:
_datamodel.StationMagnitude_swigregister(StationMagnitude)

def StationMagnitude_ClassName():
    r"""StationMagnitude_ClassName() -> char const *"""
    return _datamodel.StationMagnitude_ClassName()

def StationMagnitude_TypeInfo():
    r"""StationMagnitude_TypeInfo() -> RTTI"""
    return _datamodel.StationMagnitude_TypeInfo()

def StationMagnitude_Cast(*args):
    r"""
    StationMagnitude_Cast(BaseObject o) -> StationMagnitude
    StationMagnitude_Cast(Seiscomp::Core::BaseObjectPtr o) -> StationMagnitude
    """
    return _datamodel.StationMagnitude_Cast(*args)

def StationMagnitude_ConstCast(*args):
    r"""
    StationMagnitude_ConstCast(BaseObject o) -> StationMagnitude
    StationMagnitude_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationMagnitude
    """
    return _datamodel.StationMagnitude_ConstCast(*args)

def StationMagnitude_Meta():
    r"""StationMagnitude_Meta() -> MetaObject"""
    return _datamodel.StationMagnitude_Meta()

def StationMagnitude_Create(*args):
    r"""
    StationMagnitude_Create() -> StationMagnitude
    StationMagnitude_Create(std::string const & publicID) -> StationMagnitude
    """
    return _datamodel.StationMagnitude_Create(*args)

def StationMagnitude_Find(publicID):
    r"""StationMagnitude_Find(std::string const & publicID) -> StationMagnitude"""
    return _datamodel.StationMagnitude_Find(publicID)

class Pick(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Pick 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 _datamodel.Pick_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Pick_TypeInfo()

    def className(self):
        r"""className(Pick self) -> char const *"""
        return _datamodel.Pick_className(self)

    def typeInfo(self):
        r"""typeInfo(Pick self) -> RTTI"""
        return _datamodel.Pick_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Pick
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Pick
        """
        return _datamodel.Pick_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Pick
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Pick
        """
        return _datamodel.Pick_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Pick self, GenericArchive ar)"""
        return _datamodel.Pick_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Pick_Meta()

    def meta(self):
        r"""meta(Pick self) -> MetaObject"""
        return _datamodel.Pick_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Pick self, Pick other) -> Pick
        __init__(Pick self, std::string const & publicID) -> Pick
        """
        _datamodel.Pick_swiginit(self, _datamodel.new_Pick(*args))
    __swig_destroy__ = _datamodel.delete_Pick

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Pick
        Create(std::string const & publicID) -> Pick
        """
        return _datamodel.Pick_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Pick"""
        return _datamodel.Pick_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Pick self, Pick other) -> bool"""
        return _datamodel.Pick___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Pick self, Pick other) -> bool"""
        return _datamodel.Pick___ne__(self, other)

    def equal(self, other):
        r"""equal(Pick self, Pick other) -> bool"""
        return _datamodel.Pick_equal(self, other)

    def setTime(self, time):
        r"""setTime(Pick self, TimeQuantity time)"""
        return _datamodel.Pick_setTime(self, time)

    def time(self, *args):
        r"""
        time(Pick self) -> TimeQuantity
        time(Pick self) -> TimeQuantity
        """
        return _datamodel.Pick_time(self, *args)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(Pick self, WaveformStreamID waveformID)"""
        return _datamodel.Pick_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(Pick self) -> WaveformStreamID
        waveformID(Pick self) -> WaveformStreamID
        """
        return _datamodel.Pick_waveformID(self, *args)

    def setFilterID(self, filterID):
        r"""setFilterID(Pick self, std::string const & filterID)"""
        return _datamodel.Pick_setFilterID(self, filterID)

    def filterID(self):
        r"""filterID(Pick self) -> std::string const &"""
        return _datamodel.Pick_filterID(self)

    def setMethodID(self, methodID):
        r"""setMethodID(Pick self, std::string const & methodID)"""
        return _datamodel.Pick_setMethodID(self, methodID)

    def methodID(self):
        r"""methodID(Pick self) -> std::string const &"""
        return _datamodel.Pick_methodID(self)

    def setHorizontalSlowness(self, horizontalSlowness):
        r"""setHorizontalSlowness(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & horizontalSlowness)"""
        return _datamodel.Pick_setHorizontalSlowness(self, horizontalSlowness)

    def horizontalSlowness(self, *args):
        r"""
        horizontalSlowness(Pick self) -> RealQuantity
        horizontalSlowness(Pick self) -> RealQuantity
        """
        return _datamodel.Pick_horizontalSlowness(self, *args)

    def setBackazimuth(self, backazimuth):
        r"""setBackazimuth(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & backazimuth)"""
        return _datamodel.Pick_setBackazimuth(self, backazimuth)

    def backazimuth(self, *args):
        r"""
        backazimuth(Pick self) -> RealQuantity
        backazimuth(Pick self) -> RealQuantity
        """
        return _datamodel.Pick_backazimuth(self, *args)

    def setSlownessMethodID(self, slownessMethodID):
        r"""setSlownessMethodID(Pick self, std::string const & slownessMethodID)"""
        return _datamodel.Pick_setSlownessMethodID(self, slownessMethodID)

    def slownessMethodID(self):
        r"""slownessMethodID(Pick self) -> std::string const &"""
        return _datamodel.Pick_slownessMethodID(self)

    def setOnset(self, onset):
        r"""setOnset(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::PickOnset >::Impl const & onset)"""
        return _datamodel.Pick_setOnset(self, onset)

    def onset(self):
        r"""onset(Pick self) -> Seiscomp::DataModel::PickOnset"""
        return _datamodel.Pick_onset(self)

    def setPhaseHint(self, phaseHint):
        r"""setPhaseHint(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::Phase >::Impl const & phaseHint)"""
        return _datamodel.Pick_setPhaseHint(self, phaseHint)

    def phaseHint(self, *args):
        r"""
        phaseHint(Pick self) -> Phase
        phaseHint(Pick self) -> Phase
        """
        return _datamodel.Pick_phaseHint(self, *args)

    def setPolarity(self, polarity):
        r"""setPolarity(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::PickPolarity >::Impl const & polarity)"""
        return _datamodel.Pick_setPolarity(self, polarity)

    def polarity(self):
        r"""polarity(Pick self) -> Seiscomp::DataModel::PickPolarity"""
        return _datamodel.Pick_polarity(self)

    def setEvaluationMode(self, evaluationMode):
        r"""setEvaluationMode(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationMode >::Impl const & evaluationMode)"""
        return _datamodel.Pick_setEvaluationMode(self, evaluationMode)

    def evaluationMode(self):
        r"""evaluationMode(Pick self) -> Seiscomp::DataModel::EvaluationMode"""
        return _datamodel.Pick_evaluationMode(self)

    def setEvaluationStatus(self, evaluationStatus):
        r"""setEvaluationStatus(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationStatus >::Impl const & evaluationStatus)"""
        return _datamodel.Pick_setEvaluationStatus(self, evaluationStatus)

    def evaluationStatus(self):
        r"""evaluationStatus(Pick self) -> Seiscomp::DataModel::EvaluationStatus"""
        return _datamodel.Pick_evaluationStatus(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.Pick_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(Pick self) -> CreationInfo
        creationInfo(Pick self) -> CreationInfo
        """
        return _datamodel.Pick_creationInfo(self, *args)

    def add(self, obj):
        r"""add(Pick self, Comment obj) -> bool"""
        return _datamodel.Pick_add(self, obj)

    def remove(self, obj):
        r"""remove(Pick self, Comment obj) -> bool"""
        return _datamodel.Pick_remove(self, obj)

    def removeComment(self, *args):
        r"""
        removeComment(Pick self, size_t i) -> bool
        removeComment(Pick self, CommentIndex i) -> bool
        """
        return _datamodel.Pick_removeComment(self, *args)

    def commentCount(self):
        r"""commentCount(Pick self) -> size_t"""
        return _datamodel.Pick_commentCount(self)

    def comment(self, *args):
        r"""
        comment(Pick self, size_t i) -> Comment
        comment(Pick self, CommentIndex i) -> Comment
        """
        return _datamodel.Pick_comment(self, *args)

    def eventParameters(self):
        r"""eventParameters(Pick self) -> EventParameters"""
        return _datamodel.Pick_eventParameters(self)

    def assign(self, other):
        r"""assign(Pick self, Object other) -> bool"""
        return _datamodel.Pick_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Pick self, PublicObject parent) -> bool"""
        return _datamodel.Pick_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Pick self, PublicObject parent) -> bool"""
        return _datamodel.Pick_detachFrom(self, parent)

    def detach(self):
        r"""detach(Pick self) -> bool"""
        return _datamodel.Pick_detach(self)

    def clone(self):
        r"""clone(Pick self) -> Object"""
        return _datamodel.Pick_clone(self)

    def updateChild(self, child):
        r"""updateChild(Pick self, Object child) -> bool"""
        return _datamodel.Pick_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Pick self, Visitor visitor)"""
        return _datamodel.Pick_accept(self, visitor)

# Register Pick in _datamodel:
_datamodel.Pick_swigregister(Pick)

def Pick_ClassName():
    r"""Pick_ClassName() -> char const *"""
    return _datamodel.Pick_ClassName()

def Pick_TypeInfo():
    r"""Pick_TypeInfo() -> RTTI"""
    return _datamodel.Pick_TypeInfo()

def Pick_Cast(*args):
    r"""
    Pick_Cast(BaseObject o) -> Pick
    Pick_Cast(Seiscomp::Core::BaseObjectPtr o) -> Pick
    """
    return _datamodel.Pick_Cast(*args)

def Pick_ConstCast(*args):
    r"""
    Pick_ConstCast(BaseObject o) -> Pick
    Pick_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Pick
    """
    return _datamodel.Pick_ConstCast(*args)

def Pick_Meta():
    r"""Pick_Meta() -> MetaObject"""
    return _datamodel.Pick_Meta()

def Pick_Create(*args):
    r"""
    Pick_Create() -> Pick
    Pick_Create(std::string const & publicID) -> Pick
    """
    return _datamodel.Pick_Create(*args)

def Pick_Find(publicID):
    r"""Pick_Find(std::string const & publicID) -> Pick"""
    return _datamodel.Pick_Find(publicID)

class OriginReferenceIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::OriginReferenceIndex 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__(OriginReferenceIndex self) -> OriginReferenceIndex
        __init__(OriginReferenceIndex self, std::string const & originID) -> OriginReferenceIndex
        __init__(OriginReferenceIndex self, OriginReferenceIndex arg2) -> OriginReferenceIndex
        """
        _datamodel.OriginReferenceIndex_swiginit(self, _datamodel.new_OriginReferenceIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(OriginReferenceIndex self, OriginReferenceIndex arg2) -> bool"""
        return _datamodel.OriginReferenceIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(OriginReferenceIndex self, OriginReferenceIndex arg2) -> bool"""
        return _datamodel.OriginReferenceIndex___ne__(self, arg2)
    originID = property(_datamodel.OriginReferenceIndex_originID_get, _datamodel.OriginReferenceIndex_originID_set, doc=r"""originID : std::string""")
    __swig_destroy__ = _datamodel.delete_OriginReferenceIndex

# Register OriginReferenceIndex in _datamodel:
_datamodel.OriginReferenceIndex_swigregister(OriginReferenceIndex)

class OriginReference(Object):
    r"""Proxy of C++ Seiscomp::DataModel::OriginReference 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 _datamodel.OriginReference_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.OriginReference_TypeInfo()

    def className(self):
        r"""className(OriginReference self) -> char const *"""
        return _datamodel.OriginReference_className(self)

    def typeInfo(self):
        r"""typeInfo(OriginReference self) -> RTTI"""
        return _datamodel.OriginReference_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> OriginReference
        Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginReference
        """
        return _datamodel.OriginReference_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> OriginReference
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginReference
        """
        return _datamodel.OriginReference_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(OriginReference self, GenericArchive ar)"""
        return _datamodel.OriginReference_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.OriginReference_Meta()

    def meta(self):
        r"""meta(OriginReference self) -> MetaObject"""
        return _datamodel.OriginReference_meta(self)

    def __init__(self, *args):
        r"""
        __init__(OriginReference self) -> OriginReference
        __init__(OriginReference self, OriginReference other) -> OriginReference
        __init__(OriginReference self, std::string const & originID) -> OriginReference
        """
        _datamodel.OriginReference_swiginit(self, _datamodel.new_OriginReference(*args))
    __swig_destroy__ = _datamodel.delete_OriginReference

    def __eq__(self, other):
        r"""__eq__(OriginReference self, OriginReference other) -> bool"""
        return _datamodel.OriginReference___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(OriginReference self, OriginReference other) -> bool"""
        return _datamodel.OriginReference___ne__(self, other)

    def equal(self, other):
        r"""equal(OriginReference self, OriginReference other) -> bool"""
        return _datamodel.OriginReference_equal(self, other)

    def setOriginID(self, originID):
        r"""setOriginID(OriginReference self, std::string const & originID)"""
        return _datamodel.OriginReference_setOriginID(self, originID)

    def originID(self):
        r"""originID(OriginReference self) -> std::string const &"""
        return _datamodel.OriginReference_originID(self)

    def index(self):
        r"""index(OriginReference self) -> OriginReferenceIndex"""
        return _datamodel.OriginReference_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(OriginReference self, OriginReference lhs) -> bool"""
        return _datamodel.OriginReference_equalIndex(self, lhs)

    def event(self):
        r"""event(OriginReference self) -> Event"""
        return _datamodel.OriginReference_event(self)

    def assign(self, other):
        r"""assign(OriginReference self, Object other) -> bool"""
        return _datamodel.OriginReference_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(OriginReference self, PublicObject parent) -> bool"""
        return _datamodel.OriginReference_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(OriginReference self, PublicObject parent) -> bool"""
        return _datamodel.OriginReference_detachFrom(self, parent)

    def detach(self):
        r"""detach(OriginReference self) -> bool"""
        return _datamodel.OriginReference_detach(self)

    def clone(self):
        r"""clone(OriginReference self) -> Object"""
        return _datamodel.OriginReference_clone(self)

    def accept(self, visitor):
        r"""accept(OriginReference self, Visitor visitor)"""
        return _datamodel.OriginReference_accept(self, visitor)

# Register OriginReference in _datamodel:
_datamodel.OriginReference_swigregister(OriginReference)

def OriginReference_ClassName():
    r"""OriginReference_ClassName() -> char const *"""
    return _datamodel.OriginReference_ClassName()

def OriginReference_TypeInfo():
    r"""OriginReference_TypeInfo() -> RTTI"""
    return _datamodel.OriginReference_TypeInfo()

def OriginReference_Cast(*args):
    r"""
    OriginReference_Cast(BaseObject o) -> OriginReference
    OriginReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginReference
    """
    return _datamodel.OriginReference_Cast(*args)

def OriginReference_ConstCast(*args):
    r"""
    OriginReference_ConstCast(BaseObject o) -> OriginReference
    OriginReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginReference
    """
    return _datamodel.OriginReference_ConstCast(*args)

def OriginReference_Meta():
    r"""OriginReference_Meta() -> MetaObject"""
    return _datamodel.OriginReference_Meta()

class FocalMechanismReferenceIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::FocalMechanismReferenceIndex 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__(FocalMechanismReferenceIndex self) -> FocalMechanismReferenceIndex
        __init__(FocalMechanismReferenceIndex self, std::string const & focalMechanismID) -> FocalMechanismReferenceIndex
        __init__(FocalMechanismReferenceIndex self, FocalMechanismReferenceIndex arg2) -> FocalMechanismReferenceIndex
        """
        _datamodel.FocalMechanismReferenceIndex_swiginit(self, _datamodel.new_FocalMechanismReferenceIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(FocalMechanismReferenceIndex self, FocalMechanismReferenceIndex arg2) -> bool"""
        return _datamodel.FocalMechanismReferenceIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(FocalMechanismReferenceIndex self, FocalMechanismReferenceIndex arg2) -> bool"""
        return _datamodel.FocalMechanismReferenceIndex___ne__(self, arg2)
    focalMechanismID = property(_datamodel.FocalMechanismReferenceIndex_focalMechanismID_get, _datamodel.FocalMechanismReferenceIndex_focalMechanismID_set, doc=r"""focalMechanismID : std::string""")
    __swig_destroy__ = _datamodel.delete_FocalMechanismReferenceIndex

# Register FocalMechanismReferenceIndex in _datamodel:
_datamodel.FocalMechanismReferenceIndex_swigregister(FocalMechanismReferenceIndex)

class FocalMechanismReference(Object):
    r"""Proxy of C++ Seiscomp::DataModel::FocalMechanismReference 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 _datamodel.FocalMechanismReference_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.FocalMechanismReference_TypeInfo()

    def className(self):
        r"""className(FocalMechanismReference self) -> char const *"""
        return _datamodel.FocalMechanismReference_className(self)

    def typeInfo(self):
        r"""typeInfo(FocalMechanismReference self) -> RTTI"""
        return _datamodel.FocalMechanismReference_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> FocalMechanismReference
        Cast(Seiscomp::Core::BaseObjectPtr o) -> FocalMechanismReference
        """
        return _datamodel.FocalMechanismReference_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> FocalMechanismReference
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FocalMechanismReference
        """
        return _datamodel.FocalMechanismReference_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(FocalMechanismReference self, GenericArchive ar)"""
        return _datamodel.FocalMechanismReference_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.FocalMechanismReference_Meta()

    def meta(self):
        r"""meta(FocalMechanismReference self) -> MetaObject"""
        return _datamodel.FocalMechanismReference_meta(self)

    def __init__(self, *args):
        r"""
        __init__(FocalMechanismReference self) -> FocalMechanismReference
        __init__(FocalMechanismReference self, FocalMechanismReference other) -> FocalMechanismReference
        __init__(FocalMechanismReference self, std::string const & focalMechanismID) -> FocalMechanismReference
        """
        _datamodel.FocalMechanismReference_swiginit(self, _datamodel.new_FocalMechanismReference(*args))
    __swig_destroy__ = _datamodel.delete_FocalMechanismReference

    def __eq__(self, other):
        r"""__eq__(FocalMechanismReference self, FocalMechanismReference other) -> bool"""
        return _datamodel.FocalMechanismReference___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(FocalMechanismReference self, FocalMechanismReference other) -> bool"""
        return _datamodel.FocalMechanismReference___ne__(self, other)

    def equal(self, other):
        r"""equal(FocalMechanismReference self, FocalMechanismReference other) -> bool"""
        return _datamodel.FocalMechanismReference_equal(self, other)

    def setFocalMechanismID(self, focalMechanismID):
        r"""setFocalMechanismID(FocalMechanismReference self, std::string const & focalMechanismID)"""
        return _datamodel.FocalMechanismReference_setFocalMechanismID(self, focalMechanismID)

    def focalMechanismID(self):
        r"""focalMechanismID(FocalMechanismReference self) -> std::string const &"""
        return _datamodel.FocalMechanismReference_focalMechanismID(self)

    def index(self):
        r"""index(FocalMechanismReference self) -> FocalMechanismReferenceIndex"""
        return _datamodel.FocalMechanismReference_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(FocalMechanismReference self, FocalMechanismReference lhs) -> bool"""
        return _datamodel.FocalMechanismReference_equalIndex(self, lhs)

    def event(self):
        r"""event(FocalMechanismReference self) -> Event"""
        return _datamodel.FocalMechanismReference_event(self)

    def assign(self, other):
        r"""assign(FocalMechanismReference self, Object other) -> bool"""
        return _datamodel.FocalMechanismReference_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(FocalMechanismReference self, PublicObject parent) -> bool"""
        return _datamodel.FocalMechanismReference_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(FocalMechanismReference self, PublicObject parent) -> bool"""
        return _datamodel.FocalMechanismReference_detachFrom(self, parent)

    def detach(self):
        r"""detach(FocalMechanismReference self) -> bool"""
        return _datamodel.FocalMechanismReference_detach(self)

    def clone(self):
        r"""clone(FocalMechanismReference self) -> Object"""
        return _datamodel.FocalMechanismReference_clone(self)

    def accept(self, visitor):
        r"""accept(FocalMechanismReference self, Visitor visitor)"""
        return _datamodel.FocalMechanismReference_accept(self, visitor)

# Register FocalMechanismReference in _datamodel:
_datamodel.FocalMechanismReference_swigregister(FocalMechanismReference)

def FocalMechanismReference_ClassName():
    r"""FocalMechanismReference_ClassName() -> char const *"""
    return _datamodel.FocalMechanismReference_ClassName()

def FocalMechanismReference_TypeInfo():
    r"""FocalMechanismReference_TypeInfo() -> RTTI"""
    return _datamodel.FocalMechanismReference_TypeInfo()

def FocalMechanismReference_Cast(*args):
    r"""
    FocalMechanismReference_Cast(BaseObject o) -> FocalMechanismReference
    FocalMechanismReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> FocalMechanismReference
    """
    return _datamodel.FocalMechanismReference_Cast(*args)

def FocalMechanismReference_ConstCast(*args):
    r"""
    FocalMechanismReference_ConstCast(BaseObject o) -> FocalMechanismReference
    FocalMechanismReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FocalMechanismReference
    """
    return _datamodel.FocalMechanismReference_ConstCast(*args)

def FocalMechanismReference_Meta():
    r"""FocalMechanismReference_Meta() -> MetaObject"""
    return _datamodel.FocalMechanismReference_Meta()

class Event(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Event 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 _datamodel.Event_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Event_TypeInfo()

    def className(self):
        r"""className(Event self) -> char const *"""
        return _datamodel.Event_className(self)

    def typeInfo(self):
        r"""typeInfo(Event self) -> RTTI"""
        return _datamodel.Event_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Event
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Event
        """
        return _datamodel.Event_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Event
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Event
        """
        return _datamodel.Event_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Event self, GenericArchive ar)"""
        return _datamodel.Event_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Event_Meta()

    def meta(self):
        r"""meta(Event self) -> MetaObject"""
        return _datamodel.Event_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Event self, Event other) -> Event
        __init__(Event self, std::string const & publicID) -> Event
        """
        _datamodel.Event_swiginit(self, _datamodel.new_Event(*args))
    __swig_destroy__ = _datamodel.delete_Event

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Event
        Create(std::string const & publicID) -> Event
        """
        return _datamodel.Event_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Event"""
        return _datamodel.Event_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Event self, Event other) -> bool"""
        return _datamodel.Event___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Event self, Event other) -> bool"""
        return _datamodel.Event___ne__(self, other)

    def equal(self, other):
        r"""equal(Event self, Event other) -> bool"""
        return _datamodel.Event_equal(self, other)

    def setPreferredOriginID(self, preferredOriginID):
        r"""setPreferredOriginID(Event self, std::string const & preferredOriginID)"""
        return _datamodel.Event_setPreferredOriginID(self, preferredOriginID)

    def preferredOriginID(self):
        r"""preferredOriginID(Event self) -> std::string const &"""
        return _datamodel.Event_preferredOriginID(self)

    def setPreferredMagnitudeID(self, preferredMagnitudeID):
        r"""setPreferredMagnitudeID(Event self, std::string const & preferredMagnitudeID)"""
        return _datamodel.Event_setPreferredMagnitudeID(self, preferredMagnitudeID)

    def preferredMagnitudeID(self):
        r"""preferredMagnitudeID(Event self) -> std::string const &"""
        return _datamodel.Event_preferredMagnitudeID(self)

    def setPreferredFocalMechanismID(self, preferredFocalMechanismID):
        r"""setPreferredFocalMechanismID(Event self, std::string const & preferredFocalMechanismID)"""
        return _datamodel.Event_setPreferredFocalMechanismID(self, preferredFocalMechanismID)

    def preferredFocalMechanismID(self):
        r"""preferredFocalMechanismID(Event self) -> std::string const &"""
        return _datamodel.Event_preferredFocalMechanismID(self)

    def setType(self, type):
        r"""setType(Event self, Seiscomp::Core::Optional< Seiscomp::DataModel::EventType >::Impl const & type)"""
        return _datamodel.Event_setType(self, type)

    def type(self):
        r"""type(Event self) -> Seiscomp::DataModel::EventType"""
        return _datamodel.Event_type(self)

    def setTypeCertainty(self, typeCertainty):
        r"""setTypeCertainty(Event self, Seiscomp::Core::Optional< Seiscomp::DataModel::EventTypeCertainty >::Impl const & typeCertainty)"""
        return _datamodel.Event_setTypeCertainty(self, typeCertainty)

    def typeCertainty(self):
        r"""typeCertainty(Event self) -> Seiscomp::DataModel::EventTypeCertainty"""
        return _datamodel.Event_typeCertainty(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(Event self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.Event_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(Event self) -> CreationInfo
        creationInfo(Event self) -> CreationInfo
        """
        return _datamodel.Event_creationInfo(self, *args)

    def add(self, *args):
        r"""
        add(Event self, EventDescription obj) -> bool
        add(Event self, Comment obj) -> bool
        add(Event self, OriginReference obj) -> bool
        add(Event self, FocalMechanismReference obj) -> bool
        """
        return _datamodel.Event_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Event self, EventDescription obj) -> bool
        remove(Event self, Comment obj) -> bool
        remove(Event self, OriginReference obj) -> bool
        remove(Event self, FocalMechanismReference obj) -> bool
        """
        return _datamodel.Event_remove(self, *args)

    def removeEventDescription(self, *args):
        r"""
        removeEventDescription(Event self, size_t i) -> bool
        removeEventDescription(Event self, EventDescriptionIndex i) -> bool
        """
        return _datamodel.Event_removeEventDescription(self, *args)

    def removeComment(self, *args):
        r"""
        removeComment(Event self, size_t i) -> bool
        removeComment(Event self, CommentIndex i) -> bool
        """
        return _datamodel.Event_removeComment(self, *args)

    def removeOriginReference(self, *args):
        r"""
        removeOriginReference(Event self, size_t i) -> bool
        removeOriginReference(Event self, OriginReferenceIndex i) -> bool
        """
        return _datamodel.Event_removeOriginReference(self, *args)

    def removeFocalMechanismReference(self, *args):
        r"""
        removeFocalMechanismReference(Event self, size_t i) -> bool
        removeFocalMechanismReference(Event self, FocalMechanismReferenceIndex i) -> bool
        """
        return _datamodel.Event_removeFocalMechanismReference(self, *args)

    def eventDescriptionCount(self):
        r"""eventDescriptionCount(Event self) -> size_t"""
        return _datamodel.Event_eventDescriptionCount(self)

    def commentCount(self):
        r"""commentCount(Event self) -> size_t"""
        return _datamodel.Event_commentCount(self)

    def originReferenceCount(self):
        r"""originReferenceCount(Event self) -> size_t"""
        return _datamodel.Event_originReferenceCount(self)

    def focalMechanismReferenceCount(self):
        r"""focalMechanismReferenceCount(Event self) -> size_t"""
        return _datamodel.Event_focalMechanismReferenceCount(self)

    def eventDescription(self, *args):
        r"""
        eventDescription(Event self, size_t i) -> EventDescription
        eventDescription(Event self, EventDescriptionIndex i) -> EventDescription
        """
        return _datamodel.Event_eventDescription(self, *args)

    def comment(self, *args):
        r"""
        comment(Event self, size_t i) -> Comment
        comment(Event self, CommentIndex i) -> Comment
        """
        return _datamodel.Event_comment(self, *args)

    def originReference(self, *args):
        r"""
        originReference(Event self, size_t i) -> OriginReference
        originReference(Event self, OriginReferenceIndex i) -> OriginReference
        """
        return _datamodel.Event_originReference(self, *args)

    def focalMechanismReference(self, *args):
        r"""
        focalMechanismReference(Event self, size_t i) -> FocalMechanismReference
        focalMechanismReference(Event self, FocalMechanismReferenceIndex i) -> FocalMechanismReference
        """
        return _datamodel.Event_focalMechanismReference(self, *args)

    def eventParameters(self):
        r"""eventParameters(Event self) -> EventParameters"""
        return _datamodel.Event_eventParameters(self)

    def assign(self, other):
        r"""assign(Event self, Object other) -> bool"""
        return _datamodel.Event_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Event self, PublicObject parent) -> bool"""
        return _datamodel.Event_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Event self, PublicObject parent) -> bool"""
        return _datamodel.Event_detachFrom(self, parent)

    def detach(self):
        r"""detach(Event self) -> bool"""
        return _datamodel.Event_detach(self)

    def clone(self):
        r"""clone(Event self) -> Object"""
        return _datamodel.Event_clone(self)

    def updateChild(self, child):
        r"""updateChild(Event self, Object child) -> bool"""
        return _datamodel.Event_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Event self, Visitor visitor)"""
        return _datamodel.Event_accept(self, visitor)

# Register Event in _datamodel:
_datamodel.Event_swigregister(Event)

def Event_ClassName():
    r"""Event_ClassName() -> char const *"""
    return _datamodel.Event_ClassName()

def Event_TypeInfo():
    r"""Event_TypeInfo() -> RTTI"""
    return _datamodel.Event_TypeInfo()

def Event_Cast(*args):
    r"""
    Event_Cast(BaseObject o) -> Event
    Event_Cast(Seiscomp::Core::BaseObjectPtr o) -> Event
    """
    return _datamodel.Event_Cast(*args)

def Event_ConstCast(*args):
    r"""
    Event_ConstCast(BaseObject o) -> Event
    Event_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Event
    """
    return _datamodel.Event_ConstCast(*args)

def Event_Meta():
    r"""Event_Meta() -> MetaObject"""
    return _datamodel.Event_Meta()

def Event_Create(*args):
    r"""
    Event_Create() -> Event
    Event_Create(std::string const & publicID) -> Event
    """
    return _datamodel.Event_Create(*args)

def Event_Find(publicID):
    r"""Event_Find(std::string const & publicID) -> Event"""
    return _datamodel.Event_Find(publicID)

class ArrivalIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ArrivalIndex 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__(ArrivalIndex self) -> ArrivalIndex
        __init__(ArrivalIndex self, std::string const & pickID) -> ArrivalIndex
        __init__(ArrivalIndex self, ArrivalIndex arg2) -> ArrivalIndex
        """
        _datamodel.ArrivalIndex_swiginit(self, _datamodel.new_ArrivalIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ArrivalIndex self, ArrivalIndex arg2) -> bool"""
        return _datamodel.ArrivalIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ArrivalIndex self, ArrivalIndex arg2) -> bool"""
        return _datamodel.ArrivalIndex___ne__(self, arg2)
    pickID = property(_datamodel.ArrivalIndex_pickID_get, _datamodel.ArrivalIndex_pickID_set, doc=r"""pickID : std::string""")
    __swig_destroy__ = _datamodel.delete_ArrivalIndex

# Register ArrivalIndex in _datamodel:
_datamodel.ArrivalIndex_swigregister(ArrivalIndex)

class Arrival(Object):
    r"""Proxy of C++ Seiscomp::DataModel::Arrival 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 _datamodel.Arrival_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Arrival_TypeInfo()

    def className(self):
        r"""className(Arrival self) -> char const *"""
        return _datamodel.Arrival_className(self)

    def typeInfo(self):
        r"""typeInfo(Arrival self) -> RTTI"""
        return _datamodel.Arrival_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Arrival
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Arrival
        """
        return _datamodel.Arrival_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Arrival
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Arrival
        """
        return _datamodel.Arrival_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Arrival self, GenericArchive ar)"""
        return _datamodel.Arrival_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Arrival_Meta()

    def meta(self):
        r"""meta(Arrival self) -> MetaObject"""
        return _datamodel.Arrival_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Arrival self) -> Arrival
        __init__(Arrival self, Arrival other) -> Arrival
        """
        _datamodel.Arrival_swiginit(self, _datamodel.new_Arrival(*args))
    __swig_destroy__ = _datamodel.delete_Arrival

    def __eq__(self, other):
        r"""__eq__(Arrival self, Arrival other) -> bool"""
        return _datamodel.Arrival___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Arrival self, Arrival other) -> bool"""
        return _datamodel.Arrival___ne__(self, other)

    def equal(self, other):
        r"""equal(Arrival self, Arrival other) -> bool"""
        return _datamodel.Arrival_equal(self, other)

    def setPickID(self, pickID):
        r"""setPickID(Arrival self, std::string const & pickID)"""
        return _datamodel.Arrival_setPickID(self, pickID)

    def pickID(self):
        r"""pickID(Arrival self) -> std::string const &"""
        return _datamodel.Arrival_pickID(self)

    def setPhase(self, phase):
        r"""setPhase(Arrival self, Phase phase)"""
        return _datamodel.Arrival_setPhase(self, phase)

    def phase(self, *args):
        r"""
        phase(Arrival self) -> Phase
        phase(Arrival self) -> Phase
        """
        return _datamodel.Arrival_phase(self, *args)

    def setTimeCorrection(self, timeCorrection):
        r"""setTimeCorrection(Arrival self, Seiscomp::Core::Optional< double >::Impl const & timeCorrection)"""
        return _datamodel.Arrival_setTimeCorrection(self, timeCorrection)

    def timeCorrection(self):
        r"""timeCorrection(Arrival self) -> double"""
        return _datamodel.Arrival_timeCorrection(self)

    def setAzimuth(self, azimuth):
        r"""setAzimuth(Arrival self, Seiscomp::Core::Optional< double >::Impl const & azimuth)"""
        return _datamodel.Arrival_setAzimuth(self, azimuth)

    def azimuth(self):
        r"""azimuth(Arrival self) -> double"""
        return _datamodel.Arrival_azimuth(self)

    def setDistance(self, distance):
        r"""setDistance(Arrival self, Seiscomp::Core::Optional< double >::Impl const & distance)"""
        return _datamodel.Arrival_setDistance(self, distance)

    def distance(self):
        r"""distance(Arrival self) -> double"""
        return _datamodel.Arrival_distance(self)

    def setTakeOffAngle(self, takeOffAngle):
        r"""setTakeOffAngle(Arrival self, Seiscomp::Core::Optional< double >::Impl const & takeOffAngle)"""
        return _datamodel.Arrival_setTakeOffAngle(self, takeOffAngle)

    def takeOffAngle(self):
        r"""takeOffAngle(Arrival self) -> double"""
        return _datamodel.Arrival_takeOffAngle(self)

    def setTimeResidual(self, timeResidual):
        r"""setTimeResidual(Arrival self, Seiscomp::Core::Optional< double >::Impl const & timeResidual)"""
        return _datamodel.Arrival_setTimeResidual(self, timeResidual)

    def timeResidual(self):
        r"""timeResidual(Arrival self) -> double"""
        return _datamodel.Arrival_timeResidual(self)

    def setHorizontalSlownessResidual(self, horizontalSlownessResidual):
        r"""setHorizontalSlownessResidual(Arrival self, Seiscomp::Core::Optional< double >::Impl const & horizontalSlownessResidual)"""
        return _datamodel.Arrival_setHorizontalSlownessResidual(self, horizontalSlownessResidual)

    def horizontalSlownessResidual(self):
        r"""horizontalSlownessResidual(Arrival self) -> double"""
        return _datamodel.Arrival_horizontalSlownessResidual(self)

    def setBackazimuthResidual(self, backazimuthResidual):
        r"""setBackazimuthResidual(Arrival self, Seiscomp::Core::Optional< double >::Impl const & backazimuthResidual)"""
        return _datamodel.Arrival_setBackazimuthResidual(self, backazimuthResidual)

    def backazimuthResidual(self):
        r"""backazimuthResidual(Arrival self) -> double"""
        return _datamodel.Arrival_backazimuthResidual(self)

    def setTimeUsed(self, timeUsed):
        r"""setTimeUsed(Arrival self, Seiscomp::Core::Optional< bool >::Impl const & timeUsed)"""
        return _datamodel.Arrival_setTimeUsed(self, timeUsed)

    def timeUsed(self):
        r"""timeUsed(Arrival self) -> bool"""
        return _datamodel.Arrival_timeUsed(self)

    def setHorizontalSlownessUsed(self, horizontalSlownessUsed):
        r"""setHorizontalSlownessUsed(Arrival self, Seiscomp::Core::Optional< bool >::Impl const & horizontalSlownessUsed)"""
        return _datamodel.Arrival_setHorizontalSlownessUsed(self, horizontalSlownessUsed)

    def horizontalSlownessUsed(self):
        r"""horizontalSlownessUsed(Arrival self) -> bool"""
        return _datamodel.Arrival_horizontalSlownessUsed(self)

    def setBackazimuthUsed(self, backazimuthUsed):
        r"""setBackazimuthUsed(Arrival self, Seiscomp::Core::Optional< bool >::Impl const & backazimuthUsed)"""
        return _datamodel.Arrival_setBackazimuthUsed(self, backazimuthUsed)

    def backazimuthUsed(self):
        r"""backazimuthUsed(Arrival self) -> bool"""
        return _datamodel.Arrival_backazimuthUsed(self)

    def setWeight(self, weight):
        r"""setWeight(Arrival self, Seiscomp::Core::Optional< double >::Impl const & weight)"""
        return _datamodel.Arrival_setWeight(self, weight)

    def weight(self):
        r"""weight(Arrival self) -> double"""
        return _datamodel.Arrival_weight(self)

    def setEarthModelID(self, earthModelID):
        r"""setEarthModelID(Arrival self, std::string const & earthModelID)"""
        return _datamodel.Arrival_setEarthModelID(self, earthModelID)

    def earthModelID(self):
        r"""earthModelID(Arrival self) -> std::string const &"""
        return _datamodel.Arrival_earthModelID(self)

    def setPreliminary(self, preliminary):
        r"""setPreliminary(Arrival self, Seiscomp::Core::Optional< bool >::Impl const & preliminary)"""
        return _datamodel.Arrival_setPreliminary(self, preliminary)

    def preliminary(self):
        r"""preliminary(Arrival self) -> bool"""
        return _datamodel.Arrival_preliminary(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(Arrival self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.Arrival_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(Arrival self) -> CreationInfo
        creationInfo(Arrival self) -> CreationInfo
        """
        return _datamodel.Arrival_creationInfo(self, *args)

    def index(self):
        r"""index(Arrival self) -> ArrivalIndex"""
        return _datamodel.Arrival_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Arrival self, Arrival lhs) -> bool"""
        return _datamodel.Arrival_equalIndex(self, lhs)

    def origin(self):
        r"""origin(Arrival self) -> Origin"""
        return _datamodel.Arrival_origin(self)

    def assign(self, other):
        r"""assign(Arrival self, Object other) -> bool"""
        return _datamodel.Arrival_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Arrival self, PublicObject parent) -> bool"""
        return _datamodel.Arrival_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Arrival self, PublicObject parent) -> bool"""
        return _datamodel.Arrival_detachFrom(self, parent)

    def detach(self):
        r"""detach(Arrival self) -> bool"""
        return _datamodel.Arrival_detach(self)

    def clone(self):
        r"""clone(Arrival self) -> Object"""
        return _datamodel.Arrival_clone(self)

    def accept(self, visitor):
        r"""accept(Arrival self, Visitor visitor)"""
        return _datamodel.Arrival_accept(self, visitor)

# Register Arrival in _datamodel:
_datamodel.Arrival_swigregister(Arrival)

def Arrival_ClassName():
    r"""Arrival_ClassName() -> char const *"""
    return _datamodel.Arrival_ClassName()

def Arrival_TypeInfo():
    r"""Arrival_TypeInfo() -> RTTI"""
    return _datamodel.Arrival_TypeInfo()

def Arrival_Cast(*args):
    r"""
    Arrival_Cast(BaseObject o) -> Arrival
    Arrival_Cast(Seiscomp::Core::BaseObjectPtr o) -> Arrival
    """
    return _datamodel.Arrival_Cast(*args)

def Arrival_ConstCast(*args):
    r"""
    Arrival_ConstCast(BaseObject o) -> Arrival
    Arrival_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Arrival
    """
    return _datamodel.Arrival_ConstCast(*args)

def Arrival_Meta():
    r"""Arrival_Meta() -> MetaObject"""
    return _datamodel.Arrival_Meta()

class Origin(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Origin 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 _datamodel.Origin_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Origin_TypeInfo()

    def className(self):
        r"""className(Origin self) -> char const *"""
        return _datamodel.Origin_className(self)

    def typeInfo(self):
        r"""typeInfo(Origin self) -> RTTI"""
        return _datamodel.Origin_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Origin
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Origin
        """
        return _datamodel.Origin_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Origin
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Origin
        """
        return _datamodel.Origin_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Origin self, GenericArchive ar)"""
        return _datamodel.Origin_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Origin_Meta()

    def meta(self):
        r"""meta(Origin self) -> MetaObject"""
        return _datamodel.Origin_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Origin self, Origin other) -> Origin
        __init__(Origin self, std::string const & publicID) -> Origin
        """
        _datamodel.Origin_swiginit(self, _datamodel.new_Origin(*args))
    __swig_destroy__ = _datamodel.delete_Origin

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Origin
        Create(std::string const & publicID) -> Origin
        """
        return _datamodel.Origin_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Origin"""
        return _datamodel.Origin_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Origin self, Origin other) -> bool"""
        return _datamodel.Origin___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Origin self, Origin other) -> bool"""
        return _datamodel.Origin___ne__(self, other)

    def equal(self, other):
        r"""equal(Origin self, Origin other) -> bool"""
        return _datamodel.Origin_equal(self, other)

    def setTime(self, time):
        r"""setTime(Origin self, TimeQuantity time)"""
        return _datamodel.Origin_setTime(self, time)

    def time(self, *args):
        r"""
        time(Origin self) -> TimeQuantity
        time(Origin self) -> TimeQuantity
        """
        return _datamodel.Origin_time(self, *args)

    def setLatitude(self, latitude):
        r"""setLatitude(Origin self, RealQuantity latitude)"""
        return _datamodel.Origin_setLatitude(self, latitude)

    def latitude(self, *args):
        r"""
        latitude(Origin self) -> RealQuantity
        latitude(Origin self) -> RealQuantity
        """
        return _datamodel.Origin_latitude(self, *args)

    def setLongitude(self, longitude):
        r"""setLongitude(Origin self, RealQuantity longitude)"""
        return _datamodel.Origin_setLongitude(self, longitude)

    def longitude(self, *args):
        r"""
        longitude(Origin self) -> RealQuantity
        longitude(Origin self) -> RealQuantity
        """
        return _datamodel.Origin_longitude(self, *args)

    def setDepth(self, depth):
        r"""setDepth(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & depth)"""
        return _datamodel.Origin_setDepth(self, depth)

    def depth(self, *args):
        r"""
        depth(Origin self) -> RealQuantity
        depth(Origin self) -> RealQuantity
        """
        return _datamodel.Origin_depth(self, *args)

    def setDepthType(self, depthType):
        r"""setDepthType(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginDepthType >::Impl const & depthType)"""
        return _datamodel.Origin_setDepthType(self, depthType)

    def depthType(self):
        r"""depthType(Origin self) -> Seiscomp::DataModel::OriginDepthType"""
        return _datamodel.Origin_depthType(self)

    def setTimeFixed(self, timeFixed):
        r"""setTimeFixed(Origin self, Seiscomp::Core::Optional< bool >::Impl const & timeFixed)"""
        return _datamodel.Origin_setTimeFixed(self, timeFixed)

    def timeFixed(self):
        r"""timeFixed(Origin self) -> bool"""
        return _datamodel.Origin_timeFixed(self)

    def setEpicenterFixed(self, epicenterFixed):
        r"""setEpicenterFixed(Origin self, Seiscomp::Core::Optional< bool >::Impl const & epicenterFixed)"""
        return _datamodel.Origin_setEpicenterFixed(self, epicenterFixed)

    def epicenterFixed(self):
        r"""epicenterFixed(Origin self) -> bool"""
        return _datamodel.Origin_epicenterFixed(self)

    def setReferenceSystemID(self, referenceSystemID):
        r"""setReferenceSystemID(Origin self, std::string const & referenceSystemID)"""
        return _datamodel.Origin_setReferenceSystemID(self, referenceSystemID)

    def referenceSystemID(self):
        r"""referenceSystemID(Origin self) -> std::string const &"""
        return _datamodel.Origin_referenceSystemID(self)

    def setMethodID(self, methodID):
        r"""setMethodID(Origin self, std::string const & methodID)"""
        return _datamodel.Origin_setMethodID(self, methodID)

    def methodID(self):
        r"""methodID(Origin self) -> std::string const &"""
        return _datamodel.Origin_methodID(self)

    def setEarthModelID(self, earthModelID):
        r"""setEarthModelID(Origin self, std::string const & earthModelID)"""
        return _datamodel.Origin_setEarthModelID(self, earthModelID)

    def earthModelID(self):
        r"""earthModelID(Origin self) -> std::string const &"""
        return _datamodel.Origin_earthModelID(self)

    def setQuality(self, quality):
        r"""setQuality(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginQuality >::Impl const & quality)"""
        return _datamodel.Origin_setQuality(self, quality)

    def quality(self, *args):
        r"""
        quality(Origin self) -> OriginQuality
        quality(Origin self) -> OriginQuality
        """
        return _datamodel.Origin_quality(self, *args)

    def setUncertainty(self, uncertainty):
        r"""setUncertainty(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginUncertainty >::Impl const & uncertainty)"""
        return _datamodel.Origin_setUncertainty(self, uncertainty)

    def uncertainty(self, *args):
        r"""
        uncertainty(Origin self) -> OriginUncertainty
        uncertainty(Origin self) -> OriginUncertainty
        """
        return _datamodel.Origin_uncertainty(self, *args)

    def setType(self, type):
        r"""setType(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginType >::Impl const & type)"""
        return _datamodel.Origin_setType(self, type)

    def type(self):
        r"""type(Origin self) -> Seiscomp::DataModel::OriginType"""
        return _datamodel.Origin_type(self)

    def setEvaluationMode(self, evaluationMode):
        r"""setEvaluationMode(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationMode >::Impl const & evaluationMode)"""
        return _datamodel.Origin_setEvaluationMode(self, evaluationMode)

    def evaluationMode(self):
        r"""evaluationMode(Origin self) -> Seiscomp::DataModel::EvaluationMode"""
        return _datamodel.Origin_evaluationMode(self)

    def setEvaluationStatus(self, evaluationStatus):
        r"""setEvaluationStatus(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationStatus >::Impl const & evaluationStatus)"""
        return _datamodel.Origin_setEvaluationStatus(self, evaluationStatus)

    def evaluationStatus(self):
        r"""evaluationStatus(Origin self) -> Seiscomp::DataModel::EvaluationStatus"""
        return _datamodel.Origin_evaluationStatus(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.Origin_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(Origin self) -> CreationInfo
        creationInfo(Origin self) -> CreationInfo
        """
        return _datamodel.Origin_creationInfo(self, *args)

    def add(self, *args):
        r"""
        add(Origin self, Comment obj) -> bool
        add(Origin self, CompositeTime obj) -> bool
        add(Origin self, Arrival obj) -> bool
        add(Origin self, StationMagnitude obj) -> bool
        add(Origin self, Magnitude obj) -> bool
        """
        return _datamodel.Origin_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Origin self, Comment obj) -> bool
        remove(Origin self, CompositeTime obj) -> bool
        remove(Origin self, Arrival obj) -> bool
        remove(Origin self, StationMagnitude obj) -> bool
        remove(Origin self, Magnitude obj) -> bool
        """
        return _datamodel.Origin_remove(self, *args)

    def removeComment(self, *args):
        r"""
        removeComment(Origin self, size_t i) -> bool
        removeComment(Origin self, CommentIndex i) -> bool
        """
        return _datamodel.Origin_removeComment(self, *args)

    def removeCompositeTime(self, i):
        r"""removeCompositeTime(Origin self, size_t i) -> bool"""
        return _datamodel.Origin_removeCompositeTime(self, i)

    def removeArrival(self, *args):
        r"""
        removeArrival(Origin self, size_t i) -> bool
        removeArrival(Origin self, ArrivalIndex i) -> bool
        """
        return _datamodel.Origin_removeArrival(self, *args)

    def removeStationMagnitude(self, i):
        r"""removeStationMagnitude(Origin self, size_t i) -> bool"""
        return _datamodel.Origin_removeStationMagnitude(self, i)

    def removeMagnitude(self, i):
        r"""removeMagnitude(Origin self, size_t i) -> bool"""
        return _datamodel.Origin_removeMagnitude(self, i)

    def commentCount(self):
        r"""commentCount(Origin self) -> size_t"""
        return _datamodel.Origin_commentCount(self)

    def compositeTimeCount(self):
        r"""compositeTimeCount(Origin self) -> size_t"""
        return _datamodel.Origin_compositeTimeCount(self)

    def arrivalCount(self):
        r"""arrivalCount(Origin self) -> size_t"""
        return _datamodel.Origin_arrivalCount(self)

    def stationMagnitudeCount(self):
        r"""stationMagnitudeCount(Origin self) -> size_t"""
        return _datamodel.Origin_stationMagnitudeCount(self)

    def magnitudeCount(self):
        r"""magnitudeCount(Origin self) -> size_t"""
        return _datamodel.Origin_magnitudeCount(self)

    def comment(self, *args):
        r"""
        comment(Origin self, size_t i) -> Comment
        comment(Origin self, CommentIndex i) -> Comment
        """
        return _datamodel.Origin_comment(self, *args)

    def compositeTime(self, i):
        r"""compositeTime(Origin self, size_t i) -> CompositeTime"""
        return _datamodel.Origin_compositeTime(self, i)

    def arrival(self, *args):
        r"""
        arrival(Origin self, size_t i) -> Arrival
        arrival(Origin self, ArrivalIndex i) -> Arrival
        """
        return _datamodel.Origin_arrival(self, *args)

    def stationMagnitude(self, i):
        r"""stationMagnitude(Origin self, size_t i) -> StationMagnitude"""
        return _datamodel.Origin_stationMagnitude(self, i)

    def magnitude(self, i):
        r"""magnitude(Origin self, size_t i) -> Magnitude"""
        return _datamodel.Origin_magnitude(self, i)

    def findCompositeTime(self, compositeTime):
        r"""findCompositeTime(Origin self, CompositeTime compositeTime) -> CompositeTime"""
        return _datamodel.Origin_findCompositeTime(self, compositeTime)

    def findStationMagnitude(self, publicID):
        r"""findStationMagnitude(Origin self, std::string const & publicID) -> StationMagnitude"""
        return _datamodel.Origin_findStationMagnitude(self, publicID)

    def findMagnitude(self, publicID):
        r"""findMagnitude(Origin self, std::string const & publicID) -> Magnitude"""
        return _datamodel.Origin_findMagnitude(self, publicID)

    def eventParameters(self):
        r"""eventParameters(Origin self) -> EventParameters"""
        return _datamodel.Origin_eventParameters(self)

    def assign(self, other):
        r"""assign(Origin self, Object other) -> bool"""
        return _datamodel.Origin_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Origin self, PublicObject parent) -> bool"""
        return _datamodel.Origin_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Origin self, PublicObject parent) -> bool"""
        return _datamodel.Origin_detachFrom(self, parent)

    def detach(self):
        r"""detach(Origin self) -> bool"""
        return _datamodel.Origin_detach(self)

    def clone(self):
        r"""clone(Origin self) -> Object"""
        return _datamodel.Origin_clone(self)

    def updateChild(self, child):
        r"""updateChild(Origin self, Object child) -> bool"""
        return _datamodel.Origin_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Origin self, Visitor visitor)"""
        return _datamodel.Origin_accept(self, visitor)

# Register Origin in _datamodel:
_datamodel.Origin_swigregister(Origin)

def Origin_ClassName():
    r"""Origin_ClassName() -> char const *"""
    return _datamodel.Origin_ClassName()

def Origin_TypeInfo():
    r"""Origin_TypeInfo() -> RTTI"""
    return _datamodel.Origin_TypeInfo()

def Origin_Cast(*args):
    r"""
    Origin_Cast(BaseObject o) -> Origin
    Origin_Cast(Seiscomp::Core::BaseObjectPtr o) -> Origin
    """
    return _datamodel.Origin_Cast(*args)

def Origin_ConstCast(*args):
    r"""
    Origin_ConstCast(BaseObject o) -> Origin
    Origin_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Origin
    """
    return _datamodel.Origin_ConstCast(*args)

def Origin_Meta():
    r"""Origin_Meta() -> MetaObject"""
    return _datamodel.Origin_Meta()

def Origin_Create(*args):
    r"""
    Origin_Create() -> Origin
    Origin_Create(std::string const & publicID) -> Origin
    """
    return _datamodel.Origin_Create(*args)

def Origin_Find(publicID):
    r"""Origin_Find(std::string const & publicID) -> Origin"""
    return _datamodel.Origin_Find(publicID)

class EventParameters(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::EventParameters 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 _datamodel.EventParameters_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.EventParameters_TypeInfo()

    def className(self):
        r"""className(EventParameters self) -> char const *"""
        return _datamodel.EventParameters_className(self)

    def typeInfo(self):
        r"""typeInfo(EventParameters self) -> RTTI"""
        return _datamodel.EventParameters_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> EventParameters
        Cast(Seiscomp::Core::BaseObjectPtr o) -> EventParameters
        """
        return _datamodel.EventParameters_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> EventParameters
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventParameters
        """
        return _datamodel.EventParameters_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(EventParameters self, GenericArchive ar)"""
        return _datamodel.EventParameters_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.EventParameters_Meta()

    def meta(self):
        r"""meta(EventParameters self) -> MetaObject"""
        return _datamodel.EventParameters_meta(self)

    def __init__(self, *args):
        r"""
        __init__(EventParameters self) -> EventParameters
        __init__(EventParameters self, EventParameters other) -> EventParameters
        """
        _datamodel.EventParameters_swiginit(self, _datamodel.new_EventParameters(*args))
    __swig_destroy__ = _datamodel.delete_EventParameters

    def __eq__(self, other):
        r"""__eq__(EventParameters self, EventParameters other) -> bool"""
        return _datamodel.EventParameters___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(EventParameters self, EventParameters other) -> bool"""
        return _datamodel.EventParameters___ne__(self, other)

    def equal(self, other):
        r"""equal(EventParameters self, EventParameters other) -> bool"""
        return _datamodel.EventParameters_equal(self, other)

    def add(self, *args):
        r"""
        add(EventParameters self, Pick obj) -> bool
        add(EventParameters self, Amplitude obj) -> bool
        add(EventParameters self, Reading obj) -> bool
        add(EventParameters self, Origin obj) -> bool
        add(EventParameters self, FocalMechanism obj) -> bool
        add(EventParameters self, Event obj) -> bool
        """
        return _datamodel.EventParameters_add(self, *args)

    def remove(self, *args):
        r"""
        remove(EventParameters self, Pick obj) -> bool
        remove(EventParameters self, Amplitude obj) -> bool
        remove(EventParameters self, Reading obj) -> bool
        remove(EventParameters self, Origin obj) -> bool
        remove(EventParameters self, FocalMechanism obj) -> bool
        remove(EventParameters self, Event obj) -> bool
        """
        return _datamodel.EventParameters_remove(self, *args)

    def removePick(self, i):
        r"""removePick(EventParameters self, size_t i) -> bool"""
        return _datamodel.EventParameters_removePick(self, i)

    def removeAmplitude(self, i):
        r"""removeAmplitude(EventParameters self, size_t i) -> bool"""
        return _datamodel.EventParameters_removeAmplitude(self, i)

    def removeReading(self, i):
        r"""removeReading(EventParameters self, size_t i) -> bool"""
        return _datamodel.EventParameters_removeReading(self, i)

    def removeOrigin(self, i):
        r"""removeOrigin(EventParameters self, size_t i) -> bool"""
        return _datamodel.EventParameters_removeOrigin(self, i)

    def removeFocalMechanism(self, i):
        r"""removeFocalMechanism(EventParameters self, size_t i) -> bool"""
        return _datamodel.EventParameters_removeFocalMechanism(self, i)

    def removeEvent(self, i):
        r"""removeEvent(EventParameters self, size_t i) -> bool"""
        return _datamodel.EventParameters_removeEvent(self, i)

    def pickCount(self):
        r"""pickCount(EventParameters self) -> size_t"""
        return _datamodel.EventParameters_pickCount(self)

    def amplitudeCount(self):
        r"""amplitudeCount(EventParameters self) -> size_t"""
        return _datamodel.EventParameters_amplitudeCount(self)

    def readingCount(self):
        r"""readingCount(EventParameters self) -> size_t"""
        return _datamodel.EventParameters_readingCount(self)

    def originCount(self):
        r"""originCount(EventParameters self) -> size_t"""
        return _datamodel.EventParameters_originCount(self)

    def focalMechanismCount(self):
        r"""focalMechanismCount(EventParameters self) -> size_t"""
        return _datamodel.EventParameters_focalMechanismCount(self)

    def eventCount(self):
        r"""eventCount(EventParameters self) -> size_t"""
        return _datamodel.EventParameters_eventCount(self)

    def pick(self, i):
        r"""pick(EventParameters self, size_t i) -> Pick"""
        return _datamodel.EventParameters_pick(self, i)

    def amplitude(self, i):
        r"""amplitude(EventParameters self, size_t i) -> Amplitude"""
        return _datamodel.EventParameters_amplitude(self, i)

    def reading(self, i):
        r"""reading(EventParameters self, size_t i) -> Reading"""
        return _datamodel.EventParameters_reading(self, i)

    def origin(self, i):
        r"""origin(EventParameters self, size_t i) -> Origin"""
        return _datamodel.EventParameters_origin(self, i)

    def focalMechanism(self, i):
        r"""focalMechanism(EventParameters self, size_t i) -> FocalMechanism"""
        return _datamodel.EventParameters_focalMechanism(self, i)

    def event(self, i):
        r"""event(EventParameters self, size_t i) -> Event"""
        return _datamodel.EventParameters_event(self, i)

    def findPick(self, publicID):
        r"""findPick(EventParameters self, std::string const & publicID) -> Pick"""
        return _datamodel.EventParameters_findPick(self, publicID)

    def findAmplitude(self, publicID):
        r"""findAmplitude(EventParameters self, std::string const & publicID) -> Amplitude"""
        return _datamodel.EventParameters_findAmplitude(self, publicID)

    def findReading(self, publicID):
        r"""findReading(EventParameters self, std::string const & publicID) -> Reading"""
        return _datamodel.EventParameters_findReading(self, publicID)

    def findOrigin(self, publicID):
        r"""findOrigin(EventParameters self, std::string const & publicID) -> Origin"""
        return _datamodel.EventParameters_findOrigin(self, publicID)

    def findFocalMechanism(self, publicID):
        r"""findFocalMechanism(EventParameters self, std::string const & publicID) -> FocalMechanism"""
        return _datamodel.EventParameters_findFocalMechanism(self, publicID)

    def findEvent(self, publicID):
        r"""findEvent(EventParameters self, std::string const & publicID) -> Event"""
        return _datamodel.EventParameters_findEvent(self, publicID)

    def assign(self, other):
        r"""assign(EventParameters self, Object other) -> bool"""
        return _datamodel.EventParameters_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(EventParameters self, PublicObject parent) -> bool"""
        return _datamodel.EventParameters_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(EventParameters self, PublicObject parent) -> bool"""
        return _datamodel.EventParameters_detachFrom(self, parent)

    def detach(self):
        r"""detach(EventParameters self) -> bool"""
        return _datamodel.EventParameters_detach(self)

    def clone(self):
        r"""clone(EventParameters self) -> Object"""
        return _datamodel.EventParameters_clone(self)

    def updateChild(self, child):
        r"""updateChild(EventParameters self, Object child) -> bool"""
        return _datamodel.EventParameters_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(EventParameters self, Visitor visitor)"""
        return _datamodel.EventParameters_accept(self, visitor)

# Register EventParameters in _datamodel:
_datamodel.EventParameters_swigregister(EventParameters)

def EventParameters_ClassName():
    r"""EventParameters_ClassName() -> char const *"""
    return _datamodel.EventParameters_ClassName()

def EventParameters_TypeInfo():
    r"""EventParameters_TypeInfo() -> RTTI"""
    return _datamodel.EventParameters_TypeInfo()

def EventParameters_Cast(*args):
    r"""
    EventParameters_Cast(BaseObject o) -> EventParameters
    EventParameters_Cast(Seiscomp::Core::BaseObjectPtr o) -> EventParameters
    """
    return _datamodel.EventParameters_Cast(*args)

def EventParameters_ConstCast(*args):
    r"""
    EventParameters_ConstCast(BaseObject o) -> EventParameters
    EventParameters_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventParameters
    """
    return _datamodel.EventParameters_ConstCast(*args)

def EventParameters_Meta():
    r"""EventParameters_Meta() -> MetaObject"""
    return _datamodel.EventParameters_Meta()

class Parameter(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Parameter 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 _datamodel.Parameter_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Parameter_TypeInfo()

    def className(self):
        r"""className(Parameter self) -> char const *"""
        return _datamodel.Parameter_className(self)

    def typeInfo(self):
        r"""typeInfo(Parameter self) -> RTTI"""
        return _datamodel.Parameter_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Parameter
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Parameter
        """
        return _datamodel.Parameter_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Parameter
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Parameter
        """
        return _datamodel.Parameter_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Parameter self, GenericArchive ar)"""
        return _datamodel.Parameter_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Parameter_Meta()

    def meta(self):
        r"""meta(Parameter self) -> MetaObject"""
        return _datamodel.Parameter_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Parameter self, Parameter other) -> Parameter
        __init__(Parameter self, std::string const & publicID) -> Parameter
        """
        _datamodel.Parameter_swiginit(self, _datamodel.new_Parameter(*args))
    __swig_destroy__ = _datamodel.delete_Parameter

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Parameter
        Create(std::string const & publicID) -> Parameter
        """
        return _datamodel.Parameter_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Parameter"""
        return _datamodel.Parameter_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Parameter self, Parameter other) -> bool"""
        return _datamodel.Parameter___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Parameter self, Parameter other) -> bool"""
        return _datamodel.Parameter___ne__(self, other)

    def equal(self, other):
        r"""equal(Parameter self, Parameter other) -> bool"""
        return _datamodel.Parameter_equal(self, other)

    def setName(self, name):
        r"""setName(Parameter self, std::string const & name)"""
        return _datamodel.Parameter_setName(self, name)

    def name(self):
        r"""name(Parameter self) -> std::string const &"""
        return _datamodel.Parameter_name(self)

    def setValue(self, value):
        r"""setValue(Parameter self, std::string const & value)"""
        return _datamodel.Parameter_setValue(self, value)

    def value(self):
        r"""value(Parameter self) -> std::string const &"""
        return _datamodel.Parameter_value(self)

    def add(self, obj):
        r"""add(Parameter self, Comment obj) -> bool"""
        return _datamodel.Parameter_add(self, obj)

    def remove(self, obj):
        r"""remove(Parameter self, Comment obj) -> bool"""
        return _datamodel.Parameter_remove(self, obj)

    def removeComment(self, *args):
        r"""
        removeComment(Parameter self, size_t i) -> bool
        removeComment(Parameter self, CommentIndex i) -> bool
        """
        return _datamodel.Parameter_removeComment(self, *args)

    def commentCount(self):
        r"""commentCount(Parameter self) -> size_t"""
        return _datamodel.Parameter_commentCount(self)

    def comment(self, *args):
        r"""
        comment(Parameter self, size_t i) -> Comment
        comment(Parameter self, CommentIndex i) -> Comment
        """
        return _datamodel.Parameter_comment(self, *args)

    def parameterSet(self):
        r"""parameterSet(Parameter self) -> ParameterSet"""
        return _datamodel.Parameter_parameterSet(self)

    def assign(self, other):
        r"""assign(Parameter self, Object other) -> bool"""
        return _datamodel.Parameter_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Parameter self, PublicObject parent) -> bool"""
        return _datamodel.Parameter_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Parameter self, PublicObject parent) -> bool"""
        return _datamodel.Parameter_detachFrom(self, parent)

    def detach(self):
        r"""detach(Parameter self) -> bool"""
        return _datamodel.Parameter_detach(self)

    def clone(self):
        r"""clone(Parameter self) -> Object"""
        return _datamodel.Parameter_clone(self)

    def updateChild(self, child):
        r"""updateChild(Parameter self, Object child) -> bool"""
        return _datamodel.Parameter_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Parameter self, Visitor visitor)"""
        return _datamodel.Parameter_accept(self, visitor)

# Register Parameter in _datamodel:
_datamodel.Parameter_swigregister(Parameter)

def Parameter_ClassName():
    r"""Parameter_ClassName() -> char const *"""
    return _datamodel.Parameter_ClassName()

def Parameter_TypeInfo():
    r"""Parameter_TypeInfo() -> RTTI"""
    return _datamodel.Parameter_TypeInfo()

def Parameter_Cast(*args):
    r"""
    Parameter_Cast(BaseObject o) -> Parameter
    Parameter_Cast(Seiscomp::Core::BaseObjectPtr o) -> Parameter
    """
    return _datamodel.Parameter_Cast(*args)

def Parameter_ConstCast(*args):
    r"""
    Parameter_ConstCast(BaseObject o) -> Parameter
    Parameter_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Parameter
    """
    return _datamodel.Parameter_ConstCast(*args)

def Parameter_Meta():
    r"""Parameter_Meta() -> MetaObject"""
    return _datamodel.Parameter_Meta()

def Parameter_Create(*args):
    r"""
    Parameter_Create() -> Parameter
    Parameter_Create(std::string const & publicID) -> Parameter
    """
    return _datamodel.Parameter_Create(*args)

def Parameter_Find(publicID):
    r"""Parameter_Find(std::string const & publicID) -> Parameter"""
    return _datamodel.Parameter_Find(publicID)

class ParameterSet(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ParameterSet 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 _datamodel.ParameterSet_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ParameterSet_TypeInfo()

    def className(self):
        r"""className(ParameterSet self) -> char const *"""
        return _datamodel.ParameterSet_className(self)

    def typeInfo(self):
        r"""typeInfo(ParameterSet self) -> RTTI"""
        return _datamodel.ParameterSet_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ParameterSet
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ParameterSet
        """
        return _datamodel.ParameterSet_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ParameterSet
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ParameterSet
        """
        return _datamodel.ParameterSet_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ParameterSet self, GenericArchive ar)"""
        return _datamodel.ParameterSet_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ParameterSet_Meta()

    def meta(self):
        r"""meta(ParameterSet self) -> MetaObject"""
        return _datamodel.ParameterSet_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ParameterSet self, ParameterSet other) -> ParameterSet
        __init__(ParameterSet self, std::string const & publicID) -> ParameterSet
        """
        _datamodel.ParameterSet_swiginit(self, _datamodel.new_ParameterSet(*args))
    __swig_destroy__ = _datamodel.delete_ParameterSet

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ParameterSet
        Create(std::string const & publicID) -> ParameterSet
        """
        return _datamodel.ParameterSet_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ParameterSet"""
        return _datamodel.ParameterSet_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ParameterSet self, ParameterSet other) -> bool"""
        return _datamodel.ParameterSet___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ParameterSet self, ParameterSet other) -> bool"""
        return _datamodel.ParameterSet___ne__(self, other)

    def equal(self, other):
        r"""equal(ParameterSet self, ParameterSet other) -> bool"""
        return _datamodel.ParameterSet_equal(self, other)

    def setBaseID(self, baseID):
        r"""setBaseID(ParameterSet self, std::string const & baseID)"""
        return _datamodel.ParameterSet_setBaseID(self, baseID)

    def baseID(self):
        r"""baseID(ParameterSet self) -> std::string const &"""
        return _datamodel.ParameterSet_baseID(self)

    def setModuleID(self, moduleID):
        r"""setModuleID(ParameterSet self, std::string const & moduleID)"""
        return _datamodel.ParameterSet_setModuleID(self, moduleID)

    def moduleID(self):
        r"""moduleID(ParameterSet self) -> std::string const &"""
        return _datamodel.ParameterSet_moduleID(self)

    def setCreated(self, created):
        r"""setCreated(ParameterSet self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & created)"""
        return _datamodel.ParameterSet_setCreated(self, created)

    def created(self):
        r"""created(ParameterSet self) -> Time"""
        return _datamodel.ParameterSet_created(self)

    def add(self, *args):
        r"""
        add(ParameterSet self, Parameter obj) -> bool
        add(ParameterSet self, Comment obj) -> bool
        """
        return _datamodel.ParameterSet_add(self, *args)

    def remove(self, *args):
        r"""
        remove(ParameterSet self, Parameter obj) -> bool
        remove(ParameterSet self, Comment obj) -> bool
        """
        return _datamodel.ParameterSet_remove(self, *args)

    def removeParameter(self, i):
        r"""removeParameter(ParameterSet self, size_t i) -> bool"""
        return _datamodel.ParameterSet_removeParameter(self, i)

    def removeComment(self, *args):
        r"""
        removeComment(ParameterSet self, size_t i) -> bool
        removeComment(ParameterSet self, CommentIndex i) -> bool
        """
        return _datamodel.ParameterSet_removeComment(self, *args)

    def parameterCount(self):
        r"""parameterCount(ParameterSet self) -> size_t"""
        return _datamodel.ParameterSet_parameterCount(self)

    def commentCount(self):
        r"""commentCount(ParameterSet self) -> size_t"""
        return _datamodel.ParameterSet_commentCount(self)

    def parameter(self, i):
        r"""parameter(ParameterSet self, size_t i) -> Parameter"""
        return _datamodel.ParameterSet_parameter(self, i)

    def comment(self, *args):
        r"""
        comment(ParameterSet self, size_t i) -> Comment
        comment(ParameterSet self, CommentIndex i) -> Comment
        """
        return _datamodel.ParameterSet_comment(self, *args)

    def findParameter(self, publicID):
        r"""findParameter(ParameterSet self, std::string const & publicID) -> Parameter"""
        return _datamodel.ParameterSet_findParameter(self, publicID)

    def config(self):
        r"""config(ParameterSet self) -> Config"""
        return _datamodel.ParameterSet_config(self)

    def assign(self, other):
        r"""assign(ParameterSet self, Object other) -> bool"""
        return _datamodel.ParameterSet_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ParameterSet self, PublicObject parent) -> bool"""
        return _datamodel.ParameterSet_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ParameterSet self, PublicObject parent) -> bool"""
        return _datamodel.ParameterSet_detachFrom(self, parent)

    def detach(self):
        r"""detach(ParameterSet self) -> bool"""
        return _datamodel.ParameterSet_detach(self)

    def clone(self):
        r"""clone(ParameterSet self) -> Object"""
        return _datamodel.ParameterSet_clone(self)

    def updateChild(self, child):
        r"""updateChild(ParameterSet self, Object child) -> bool"""
        return _datamodel.ParameterSet_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ParameterSet self, Visitor visitor)"""
        return _datamodel.ParameterSet_accept(self, visitor)

# Register ParameterSet in _datamodel:
_datamodel.ParameterSet_swigregister(ParameterSet)

def ParameterSet_ClassName():
    r"""ParameterSet_ClassName() -> char const *"""
    return _datamodel.ParameterSet_ClassName()

def ParameterSet_TypeInfo():
    r"""ParameterSet_TypeInfo() -> RTTI"""
    return _datamodel.ParameterSet_TypeInfo()

def ParameterSet_Cast(*args):
    r"""
    ParameterSet_Cast(BaseObject o) -> ParameterSet
    ParameterSet_Cast(Seiscomp::Core::BaseObjectPtr o) -> ParameterSet
    """
    return _datamodel.ParameterSet_Cast(*args)

def ParameterSet_ConstCast(*args):
    r"""
    ParameterSet_ConstCast(BaseObject o) -> ParameterSet
    ParameterSet_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ParameterSet
    """
    return _datamodel.ParameterSet_ConstCast(*args)

def ParameterSet_Meta():
    r"""ParameterSet_Meta() -> MetaObject"""
    return _datamodel.ParameterSet_Meta()

def ParameterSet_Create(*args):
    r"""
    ParameterSet_Create() -> ParameterSet
    ParameterSet_Create(std::string const & publicID) -> ParameterSet
    """
    return _datamodel.ParameterSet_Create(*args)

def ParameterSet_Find(publicID):
    r"""ParameterSet_Find(std::string const & publicID) -> ParameterSet"""
    return _datamodel.ParameterSet_Find(publicID)

class SetupIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::SetupIndex 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__(SetupIndex self) -> SetupIndex
        __init__(SetupIndex self, std::string const & name) -> SetupIndex
        __init__(SetupIndex self, SetupIndex arg2) -> SetupIndex
        """
        _datamodel.SetupIndex_swiginit(self, _datamodel.new_SetupIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(SetupIndex self, SetupIndex arg2) -> bool"""
        return _datamodel.SetupIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(SetupIndex self, SetupIndex arg2) -> bool"""
        return _datamodel.SetupIndex___ne__(self, arg2)
    name = property(_datamodel.SetupIndex_name_get, _datamodel.SetupIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_SetupIndex

# Register SetupIndex in _datamodel:
_datamodel.SetupIndex_swigregister(SetupIndex)

class Setup(Object):
    r"""Proxy of C++ Seiscomp::DataModel::Setup 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 _datamodel.Setup_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Setup_TypeInfo()

    def className(self):
        r"""className(Setup self) -> char const *"""
        return _datamodel.Setup_className(self)

    def typeInfo(self):
        r"""typeInfo(Setup self) -> RTTI"""
        return _datamodel.Setup_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Setup
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Setup
        """
        return _datamodel.Setup_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Setup
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Setup
        """
        return _datamodel.Setup_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Setup self, GenericArchive ar)"""
        return _datamodel.Setup_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Setup_Meta()

    def meta(self):
        r"""meta(Setup self) -> MetaObject"""
        return _datamodel.Setup_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Setup self) -> Setup
        __init__(Setup self, Setup other) -> Setup
        """
        _datamodel.Setup_swiginit(self, _datamodel.new_Setup(*args))
    __swig_destroy__ = _datamodel.delete_Setup

    def __eq__(self, other):
        r"""__eq__(Setup self, Setup other) -> bool"""
        return _datamodel.Setup___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Setup self, Setup other) -> bool"""
        return _datamodel.Setup___ne__(self, other)

    def equal(self, other):
        r"""equal(Setup self, Setup other) -> bool"""
        return _datamodel.Setup_equal(self, other)

    def setName(self, name):
        r"""setName(Setup self, std::string const & name)"""
        return _datamodel.Setup_setName(self, name)

    def name(self):
        r"""name(Setup self) -> std::string const &"""
        return _datamodel.Setup_name(self)

    def setParameterSetID(self, parameterSetID):
        r"""setParameterSetID(Setup self, std::string const & parameterSetID)"""
        return _datamodel.Setup_setParameterSetID(self, parameterSetID)

    def parameterSetID(self):
        r"""parameterSetID(Setup self) -> std::string const &"""
        return _datamodel.Setup_parameterSetID(self)

    def setEnabled(self, enabled):
        r"""setEnabled(Setup self, bool enabled)"""
        return _datamodel.Setup_setEnabled(self, enabled)

    def enabled(self):
        r"""enabled(Setup self) -> bool"""
        return _datamodel.Setup_enabled(self)

    def index(self):
        r"""index(Setup self) -> SetupIndex"""
        return _datamodel.Setup_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Setup self, Setup lhs) -> bool"""
        return _datamodel.Setup_equalIndex(self, lhs)

    def configStation(self):
        r"""configStation(Setup self) -> ConfigStation"""
        return _datamodel.Setup_configStation(self)

    def assign(self, other):
        r"""assign(Setup self, Object other) -> bool"""
        return _datamodel.Setup_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Setup self, PublicObject parent) -> bool"""
        return _datamodel.Setup_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Setup self, PublicObject parent) -> bool"""
        return _datamodel.Setup_detachFrom(self, parent)

    def detach(self):
        r"""detach(Setup self) -> bool"""
        return _datamodel.Setup_detach(self)

    def clone(self):
        r"""clone(Setup self) -> Object"""
        return _datamodel.Setup_clone(self)

    def accept(self, visitor):
        r"""accept(Setup self, Visitor visitor)"""
        return _datamodel.Setup_accept(self, visitor)

# Register Setup in _datamodel:
_datamodel.Setup_swigregister(Setup)

def Setup_ClassName():
    r"""Setup_ClassName() -> char const *"""
    return _datamodel.Setup_ClassName()

def Setup_TypeInfo():
    r"""Setup_TypeInfo() -> RTTI"""
    return _datamodel.Setup_TypeInfo()

def Setup_Cast(*args):
    r"""
    Setup_Cast(BaseObject o) -> Setup
    Setup_Cast(Seiscomp::Core::BaseObjectPtr o) -> Setup
    """
    return _datamodel.Setup_Cast(*args)

def Setup_ConstCast(*args):
    r"""
    Setup_ConstCast(BaseObject o) -> Setup
    Setup_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Setup
    """
    return _datamodel.Setup_ConstCast(*args)

def Setup_Meta():
    r"""Setup_Meta() -> MetaObject"""
    return _datamodel.Setup_Meta()

class ConfigStationIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ConfigStationIndex 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__(ConfigStationIndex self) -> ConfigStationIndex
        __init__(ConfigStationIndex self, std::string const & networkCode, std::string const & stationCode) -> ConfigStationIndex
        __init__(ConfigStationIndex self, ConfigStationIndex arg2) -> ConfigStationIndex
        """
        _datamodel.ConfigStationIndex_swiginit(self, _datamodel.new_ConfigStationIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ConfigStationIndex self, ConfigStationIndex arg2) -> bool"""
        return _datamodel.ConfigStationIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ConfigStationIndex self, ConfigStationIndex arg2) -> bool"""
        return _datamodel.ConfigStationIndex___ne__(self, arg2)
    networkCode = property(_datamodel.ConfigStationIndex_networkCode_get, _datamodel.ConfigStationIndex_networkCode_set, doc=r"""networkCode : std::string""")
    stationCode = property(_datamodel.ConfigStationIndex_stationCode_get, _datamodel.ConfigStationIndex_stationCode_set, doc=r"""stationCode : std::string""")
    __swig_destroy__ = _datamodel.delete_ConfigStationIndex

# Register ConfigStationIndex in _datamodel:
_datamodel.ConfigStationIndex_swigregister(ConfigStationIndex)

class ConfigStation(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ConfigStation 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 _datamodel.ConfigStation_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ConfigStation_TypeInfo()

    def className(self):
        r"""className(ConfigStation self) -> char const *"""
        return _datamodel.ConfigStation_className(self)

    def typeInfo(self):
        r"""typeInfo(ConfigStation self) -> RTTI"""
        return _datamodel.ConfigStation_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ConfigStation
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigStation
        """
        return _datamodel.ConfigStation_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ConfigStation
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigStation
        """
        return _datamodel.ConfigStation_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ConfigStation self, GenericArchive ar)"""
        return _datamodel.ConfigStation_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ConfigStation_Meta()

    def meta(self):
        r"""meta(ConfigStation self) -> MetaObject"""
        return _datamodel.ConfigStation_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ConfigStation self, ConfigStation other) -> ConfigStation
        __init__(ConfigStation self, std::string const & publicID) -> ConfigStation
        """
        _datamodel.ConfigStation_swiginit(self, _datamodel.new_ConfigStation(*args))
    __swig_destroy__ = _datamodel.delete_ConfigStation

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ConfigStation
        Create(std::string const & publicID) -> ConfigStation
        """
        return _datamodel.ConfigStation_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ConfigStation"""
        return _datamodel.ConfigStation_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ConfigStation self, ConfigStation other) -> bool"""
        return _datamodel.ConfigStation___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ConfigStation self, ConfigStation other) -> bool"""
        return _datamodel.ConfigStation___ne__(self, other)

    def equal(self, other):
        r"""equal(ConfigStation self, ConfigStation other) -> bool"""
        return _datamodel.ConfigStation_equal(self, other)

    def setNetworkCode(self, networkCode):
        r"""setNetworkCode(ConfigStation self, std::string const & networkCode)"""
        return _datamodel.ConfigStation_setNetworkCode(self, networkCode)

    def networkCode(self):
        r"""networkCode(ConfigStation self) -> std::string const &"""
        return _datamodel.ConfigStation_networkCode(self)

    def setStationCode(self, stationCode):
        r"""setStationCode(ConfigStation self, std::string const & stationCode)"""
        return _datamodel.ConfigStation_setStationCode(self, stationCode)

    def stationCode(self):
        r"""stationCode(ConfigStation self) -> std::string const &"""
        return _datamodel.ConfigStation_stationCode(self)

    def setEnabled(self, enabled):
        r"""setEnabled(ConfigStation self, bool enabled)"""
        return _datamodel.ConfigStation_setEnabled(self, enabled)

    def enabled(self):
        r"""enabled(ConfigStation self) -> bool"""
        return _datamodel.ConfigStation_enabled(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(ConfigStation self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.ConfigStation_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(ConfigStation self) -> CreationInfo
        creationInfo(ConfigStation self) -> CreationInfo
        """
        return _datamodel.ConfigStation_creationInfo(self, *args)

    def index(self):
        r"""index(ConfigStation self) -> ConfigStationIndex"""
        return _datamodel.ConfigStation_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ConfigStation self, ConfigStation lhs) -> bool"""
        return _datamodel.ConfigStation_equalIndex(self, lhs)

    def add(self, obj):
        r"""add(ConfigStation self, Setup obj) -> bool"""
        return _datamodel.ConfigStation_add(self, obj)

    def remove(self, obj):
        r"""remove(ConfigStation self, Setup obj) -> bool"""
        return _datamodel.ConfigStation_remove(self, obj)

    def removeSetup(self, *args):
        r"""
        removeSetup(ConfigStation self, size_t i) -> bool
        removeSetup(ConfigStation self, SetupIndex i) -> bool
        """
        return _datamodel.ConfigStation_removeSetup(self, *args)

    def setupCount(self):
        r"""setupCount(ConfigStation self) -> size_t"""
        return _datamodel.ConfigStation_setupCount(self)

    def setup(self, *args):
        r"""
        setup(ConfigStation self, size_t i) -> Setup
        setup(ConfigStation self, SetupIndex i) -> Setup
        """
        return _datamodel.ConfigStation_setup(self, *args)

    def configModule(self):
        r"""configModule(ConfigStation self) -> ConfigModule"""
        return _datamodel.ConfigStation_configModule(self)

    def assign(self, other):
        r"""assign(ConfigStation self, Object other) -> bool"""
        return _datamodel.ConfigStation_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ConfigStation self, PublicObject parent) -> bool"""
        return _datamodel.ConfigStation_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ConfigStation self, PublicObject parent) -> bool"""
        return _datamodel.ConfigStation_detachFrom(self, parent)

    def detach(self):
        r"""detach(ConfigStation self) -> bool"""
        return _datamodel.ConfigStation_detach(self)

    def clone(self):
        r"""clone(ConfigStation self) -> Object"""
        return _datamodel.ConfigStation_clone(self)

    def updateChild(self, child):
        r"""updateChild(ConfigStation self, Object child) -> bool"""
        return _datamodel.ConfigStation_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ConfigStation self, Visitor visitor)"""
        return _datamodel.ConfigStation_accept(self, visitor)

# Register ConfigStation in _datamodel:
_datamodel.ConfigStation_swigregister(ConfigStation)

def ConfigStation_ClassName():
    r"""ConfigStation_ClassName() -> char const *"""
    return _datamodel.ConfigStation_ClassName()

def ConfigStation_TypeInfo():
    r"""ConfigStation_TypeInfo() -> RTTI"""
    return _datamodel.ConfigStation_TypeInfo()

def ConfigStation_Cast(*args):
    r"""
    ConfigStation_Cast(BaseObject o) -> ConfigStation
    ConfigStation_Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigStation
    """
    return _datamodel.ConfigStation_Cast(*args)

def ConfigStation_ConstCast(*args):
    r"""
    ConfigStation_ConstCast(BaseObject o) -> ConfigStation
    ConfigStation_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigStation
    """
    return _datamodel.ConfigStation_ConstCast(*args)

def ConfigStation_Meta():
    r"""ConfigStation_Meta() -> MetaObject"""
    return _datamodel.ConfigStation_Meta()

def ConfigStation_Create(*args):
    r"""
    ConfigStation_Create() -> ConfigStation
    ConfigStation_Create(std::string const & publicID) -> ConfigStation
    """
    return _datamodel.ConfigStation_Create(*args)

def ConfigStation_Find(publicID):
    r"""ConfigStation_Find(std::string const & publicID) -> ConfigStation"""
    return _datamodel.ConfigStation_Find(publicID)

class ConfigModule(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ConfigModule 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 _datamodel.ConfigModule_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ConfigModule_TypeInfo()

    def className(self):
        r"""className(ConfigModule self) -> char const *"""
        return _datamodel.ConfigModule_className(self)

    def typeInfo(self):
        r"""typeInfo(ConfigModule self) -> RTTI"""
        return _datamodel.ConfigModule_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ConfigModule
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigModule
        """
        return _datamodel.ConfigModule_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ConfigModule
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigModule
        """
        return _datamodel.ConfigModule_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ConfigModule self, GenericArchive ar)"""
        return _datamodel.ConfigModule_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ConfigModule_Meta()

    def meta(self):
        r"""meta(ConfigModule self) -> MetaObject"""
        return _datamodel.ConfigModule_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ConfigModule self, ConfigModule other) -> ConfigModule
        __init__(ConfigModule self, std::string const & publicID) -> ConfigModule
        """
        _datamodel.ConfigModule_swiginit(self, _datamodel.new_ConfigModule(*args))
    __swig_destroy__ = _datamodel.delete_ConfigModule

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ConfigModule
        Create(std::string const & publicID) -> ConfigModule
        """
        return _datamodel.ConfigModule_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ConfigModule"""
        return _datamodel.ConfigModule_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ConfigModule self, ConfigModule other) -> bool"""
        return _datamodel.ConfigModule___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ConfigModule self, ConfigModule other) -> bool"""
        return _datamodel.ConfigModule___ne__(self, other)

    def equal(self, other):
        r"""equal(ConfigModule self, ConfigModule other) -> bool"""
        return _datamodel.ConfigModule_equal(self, other)

    def setName(self, name):
        r"""setName(ConfigModule self, std::string const & name)"""
        return _datamodel.ConfigModule_setName(self, name)

    def name(self):
        r"""name(ConfigModule self) -> std::string const &"""
        return _datamodel.ConfigModule_name(self)

    def setParameterSetID(self, parameterSetID):
        r"""setParameterSetID(ConfigModule self, std::string const & parameterSetID)"""
        return _datamodel.ConfigModule_setParameterSetID(self, parameterSetID)

    def parameterSetID(self):
        r"""parameterSetID(ConfigModule self) -> std::string const &"""
        return _datamodel.ConfigModule_parameterSetID(self)

    def setEnabled(self, enabled):
        r"""setEnabled(ConfigModule self, bool enabled)"""
        return _datamodel.ConfigModule_setEnabled(self, enabled)

    def enabled(self):
        r"""enabled(ConfigModule self) -> bool"""
        return _datamodel.ConfigModule_enabled(self)

    def add(self, obj):
        r"""add(ConfigModule self, ConfigStation obj) -> bool"""
        return _datamodel.ConfigModule_add(self, obj)

    def remove(self, obj):
        r"""remove(ConfigModule self, ConfigStation obj) -> bool"""
        return _datamodel.ConfigModule_remove(self, obj)

    def removeConfigStation(self, *args):
        r"""
        removeConfigStation(ConfigModule self, size_t i) -> bool
        removeConfigStation(ConfigModule self, ConfigStationIndex i) -> bool
        """
        return _datamodel.ConfigModule_removeConfigStation(self, *args)

    def configStationCount(self):
        r"""configStationCount(ConfigModule self) -> size_t"""
        return _datamodel.ConfigModule_configStationCount(self)

    def configStation(self, *args):
        r"""
        configStation(ConfigModule self, size_t i) -> ConfigStation
        configStation(ConfigModule self, ConfigStationIndex i) -> ConfigStation
        """
        return _datamodel.ConfigModule_configStation(self, *args)

    def findConfigStation(self, publicID):
        r"""findConfigStation(ConfigModule self, std::string const & publicID) -> ConfigStation"""
        return _datamodel.ConfigModule_findConfigStation(self, publicID)

    def config(self):
        r"""config(ConfigModule self) -> Config"""
        return _datamodel.ConfigModule_config(self)

    def assign(self, other):
        r"""assign(ConfigModule self, Object other) -> bool"""
        return _datamodel.ConfigModule_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ConfigModule self, PublicObject parent) -> bool"""
        return _datamodel.ConfigModule_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ConfigModule self, PublicObject parent) -> bool"""
        return _datamodel.ConfigModule_detachFrom(self, parent)

    def detach(self):
        r"""detach(ConfigModule self) -> bool"""
        return _datamodel.ConfigModule_detach(self)

    def clone(self):
        r"""clone(ConfigModule self) -> Object"""
        return _datamodel.ConfigModule_clone(self)

    def updateChild(self, child):
        r"""updateChild(ConfigModule self, Object child) -> bool"""
        return _datamodel.ConfigModule_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ConfigModule self, Visitor visitor)"""
        return _datamodel.ConfigModule_accept(self, visitor)

# Register ConfigModule in _datamodel:
_datamodel.ConfigModule_swigregister(ConfigModule)

def ConfigModule_ClassName():
    r"""ConfigModule_ClassName() -> char const *"""
    return _datamodel.ConfigModule_ClassName()

def ConfigModule_TypeInfo():
    r"""ConfigModule_TypeInfo() -> RTTI"""
    return _datamodel.ConfigModule_TypeInfo()

def ConfigModule_Cast(*args):
    r"""
    ConfigModule_Cast(BaseObject o) -> ConfigModule
    ConfigModule_Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigModule
    """
    return _datamodel.ConfigModule_Cast(*args)

def ConfigModule_ConstCast(*args):
    r"""
    ConfigModule_ConstCast(BaseObject o) -> ConfigModule
    ConfigModule_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigModule
    """
    return _datamodel.ConfigModule_ConstCast(*args)

def ConfigModule_Meta():
    r"""ConfigModule_Meta() -> MetaObject"""
    return _datamodel.ConfigModule_Meta()

def ConfigModule_Create(*args):
    r"""
    ConfigModule_Create() -> ConfigModule
    ConfigModule_Create(std::string const & publicID) -> ConfigModule
    """
    return _datamodel.ConfigModule_Create(*args)

def ConfigModule_Find(publicID):
    r"""ConfigModule_Find(std::string const & publicID) -> ConfigModule"""
    return _datamodel.ConfigModule_Find(publicID)

class Config(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Config 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 _datamodel.Config_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Config_TypeInfo()

    def className(self):
        r"""className(Config self) -> char const *"""
        return _datamodel.Config_className(self)

    def typeInfo(self):
        r"""typeInfo(Config self) -> RTTI"""
        return _datamodel.Config_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Config
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Config
        """
        return _datamodel.Config_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Config
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Config
        """
        return _datamodel.Config_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Config self, GenericArchive ar)"""
        return _datamodel.Config_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Config_Meta()

    def meta(self):
        r"""meta(Config self) -> MetaObject"""
        return _datamodel.Config_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Config self) -> Config
        __init__(Config self, Config other) -> Config
        """
        _datamodel.Config_swiginit(self, _datamodel.new_Config(*args))
    __swig_destroy__ = _datamodel.delete_Config

    def __eq__(self, other):
        r"""__eq__(Config self, Config other) -> bool"""
        return _datamodel.Config___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Config self, Config other) -> bool"""
        return _datamodel.Config___ne__(self, other)

    def equal(self, other):
        r"""equal(Config self, Config other) -> bool"""
        return _datamodel.Config_equal(self, other)

    def add(self, *args):
        r"""
        add(Config self, ParameterSet obj) -> bool
        add(Config self, ConfigModule obj) -> bool
        """
        return _datamodel.Config_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Config self, ParameterSet obj) -> bool
        remove(Config self, ConfigModule obj) -> bool
        """
        return _datamodel.Config_remove(self, *args)

    def removeParameterSet(self, i):
        r"""removeParameterSet(Config self, size_t i) -> bool"""
        return _datamodel.Config_removeParameterSet(self, i)

    def removeConfigModule(self, i):
        r"""removeConfigModule(Config self, size_t i) -> bool"""
        return _datamodel.Config_removeConfigModule(self, i)

    def parameterSetCount(self):
        r"""parameterSetCount(Config self) -> size_t"""
        return _datamodel.Config_parameterSetCount(self)

    def configModuleCount(self):
        r"""configModuleCount(Config self) -> size_t"""
        return _datamodel.Config_configModuleCount(self)

    def parameterSet(self, i):
        r"""parameterSet(Config self, size_t i) -> ParameterSet"""
        return _datamodel.Config_parameterSet(self, i)

    def configModule(self, i):
        r"""configModule(Config self, size_t i) -> ConfigModule"""
        return _datamodel.Config_configModule(self, i)

    def findParameterSet(self, publicID):
        r"""findParameterSet(Config self, std::string const & publicID) -> ParameterSet"""
        return _datamodel.Config_findParameterSet(self, publicID)

    def findConfigModule(self, publicID):
        r"""findConfigModule(Config self, std::string const & publicID) -> ConfigModule"""
        return _datamodel.Config_findConfigModule(self, publicID)

    def assign(self, other):
        r"""assign(Config self, Object other) -> bool"""
        return _datamodel.Config_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Config self, PublicObject parent) -> bool"""
        return _datamodel.Config_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Config self, PublicObject parent) -> bool"""
        return _datamodel.Config_detachFrom(self, parent)

    def detach(self):
        r"""detach(Config self) -> bool"""
        return _datamodel.Config_detach(self)

    def clone(self):
        r"""clone(Config self) -> Object"""
        return _datamodel.Config_clone(self)

    def updateChild(self, child):
        r"""updateChild(Config self, Object child) -> bool"""
        return _datamodel.Config_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Config self, Visitor visitor)"""
        return _datamodel.Config_accept(self, visitor)

# Register Config in _datamodel:
_datamodel.Config_swigregister(Config)

def Config_ClassName():
    r"""Config_ClassName() -> char const *"""
    return _datamodel.Config_ClassName()

def Config_TypeInfo():
    r"""Config_TypeInfo() -> RTTI"""
    return _datamodel.Config_TypeInfo()

def Config_Cast(*args):
    r"""
    Config_Cast(BaseObject o) -> Config
    Config_Cast(Seiscomp::Core::BaseObjectPtr o) -> Config
    """
    return _datamodel.Config_Cast(*args)

def Config_ConstCast(*args):
    r"""
    Config_ConstCast(BaseObject o) -> Config
    Config_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Config
    """
    return _datamodel.Config_ConstCast(*args)

def Config_Meta():
    r"""Config_Meta() -> MetaObject"""
    return _datamodel.Config_Meta()

class QCLogIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::QCLogIndex 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__(QCLogIndex self) -> QCLogIndex
        __init__(QCLogIndex self, Time start, WaveformStreamID waveformID) -> QCLogIndex
        __init__(QCLogIndex self, QCLogIndex arg2) -> QCLogIndex
        """
        _datamodel.QCLogIndex_swiginit(self, _datamodel.new_QCLogIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(QCLogIndex self, QCLogIndex arg2) -> bool"""
        return _datamodel.QCLogIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(QCLogIndex self, QCLogIndex arg2) -> bool"""
        return _datamodel.QCLogIndex___ne__(self, arg2)
    start = property(_datamodel.QCLogIndex_start_get, _datamodel.QCLogIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    waveformID = property(_datamodel.QCLogIndex_waveformID_get, _datamodel.QCLogIndex_waveformID_set, doc=r"""waveformID : Seiscomp::DataModel::WaveformStreamID""")
    __swig_destroy__ = _datamodel.delete_QCLogIndex

# Register QCLogIndex in _datamodel:
_datamodel.QCLogIndex_swigregister(QCLogIndex)

class QCLog(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::QCLog 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 _datamodel.QCLog_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.QCLog_TypeInfo()

    def className(self):
        r"""className(QCLog self) -> char const *"""
        return _datamodel.QCLog_className(self)

    def typeInfo(self):
        r"""typeInfo(QCLog self) -> RTTI"""
        return _datamodel.QCLog_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> QCLog
        Cast(Seiscomp::Core::BaseObjectPtr o) -> QCLog
        """
        return _datamodel.QCLog_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> QCLog
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> QCLog
        """
        return _datamodel.QCLog_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(QCLog self, GenericArchive ar)"""
        return _datamodel.QCLog_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.QCLog_Meta()

    def meta(self):
        r"""meta(QCLog self) -> MetaObject"""
        return _datamodel.QCLog_meta(self)

    def __init__(self, *args):
        r"""
        __init__(QCLog self, QCLog other) -> QCLog
        __init__(QCLog self, std::string const & publicID) -> QCLog
        """
        _datamodel.QCLog_swiginit(self, _datamodel.new_QCLog(*args))
    __swig_destroy__ = _datamodel.delete_QCLog

    @staticmethod
    def Create(*args):
        r"""
        Create() -> QCLog
        Create(std::string const & publicID) -> QCLog
        """
        return _datamodel.QCLog_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> QCLog"""
        return _datamodel.QCLog_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(QCLog self, QCLog other) -> bool"""
        return _datamodel.QCLog___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(QCLog self, QCLog other) -> bool"""
        return _datamodel.QCLog___ne__(self, other)

    def equal(self, other):
        r"""equal(QCLog self, QCLog other) -> bool"""
        return _datamodel.QCLog_equal(self, other)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(QCLog self, WaveformStreamID waveformID)"""
        return _datamodel.QCLog_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(QCLog self) -> WaveformStreamID
        waveformID(QCLog self) -> WaveformStreamID
        """
        return _datamodel.QCLog_waveformID(self, *args)

    def setCreatorID(self, creatorID):
        r"""setCreatorID(QCLog self, std::string const & creatorID)"""
        return _datamodel.QCLog_setCreatorID(self, creatorID)

    def creatorID(self):
        r"""creatorID(QCLog self) -> std::string const &"""
        return _datamodel.QCLog_creatorID(self)

    def setCreated(self, created):
        r"""setCreated(QCLog self, Time created)"""
        return _datamodel.QCLog_setCreated(self, created)

    def created(self):
        r"""created(QCLog self) -> Time"""
        return _datamodel.QCLog_created(self)

    def setStart(self, start):
        r"""setStart(QCLog self, Time start)"""
        return _datamodel.QCLog_setStart(self, start)

    def start(self):
        r"""start(QCLog self) -> Time"""
        return _datamodel.QCLog_start(self)

    def setEnd(self, end):
        r"""setEnd(QCLog self, Time end)"""
        return _datamodel.QCLog_setEnd(self, end)

    def end(self):
        r"""end(QCLog self) -> Time"""
        return _datamodel.QCLog_end(self)

    def setMessage(self, message):
        r"""setMessage(QCLog self, std::string const & message)"""
        return _datamodel.QCLog_setMessage(self, message)

    def message(self):
        r"""message(QCLog self) -> std::string const &"""
        return _datamodel.QCLog_message(self)

    def index(self):
        r"""index(QCLog self) -> QCLogIndex"""
        return _datamodel.QCLog_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(QCLog self, QCLog lhs) -> bool"""
        return _datamodel.QCLog_equalIndex(self, lhs)

    def qualityControl(self):
        r"""qualityControl(QCLog self) -> QualityControl"""
        return _datamodel.QCLog_qualityControl(self)

    def assign(self, other):
        r"""assign(QCLog self, Object other) -> bool"""
        return _datamodel.QCLog_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(QCLog self, PublicObject parent) -> bool"""
        return _datamodel.QCLog_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(QCLog self, PublicObject parent) -> bool"""
        return _datamodel.QCLog_detachFrom(self, parent)

    def detach(self):
        r"""detach(QCLog self) -> bool"""
        return _datamodel.QCLog_detach(self)

    def clone(self):
        r"""clone(QCLog self) -> Object"""
        return _datamodel.QCLog_clone(self)

    def updateChild(self, child):
        r"""updateChild(QCLog self, Object child) -> bool"""
        return _datamodel.QCLog_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(QCLog self, Visitor visitor)"""
        return _datamodel.QCLog_accept(self, visitor)

# Register QCLog in _datamodel:
_datamodel.QCLog_swigregister(QCLog)

def QCLog_ClassName():
    r"""QCLog_ClassName() -> char const *"""
    return _datamodel.QCLog_ClassName()

def QCLog_TypeInfo():
    r"""QCLog_TypeInfo() -> RTTI"""
    return _datamodel.QCLog_TypeInfo()

def QCLog_Cast(*args):
    r"""
    QCLog_Cast(BaseObject o) -> QCLog
    QCLog_Cast(Seiscomp::Core::BaseObjectPtr o) -> QCLog
    """
    return _datamodel.QCLog_Cast(*args)

def QCLog_ConstCast(*args):
    r"""
    QCLog_ConstCast(BaseObject o) -> QCLog
    QCLog_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> QCLog
    """
    return _datamodel.QCLog_ConstCast(*args)

def QCLog_Meta():
    r"""QCLog_Meta() -> MetaObject"""
    return _datamodel.QCLog_Meta()

def QCLog_Create(*args):
    r"""
    QCLog_Create() -> QCLog
    QCLog_Create(std::string const & publicID) -> QCLog
    """
    return _datamodel.QCLog_Create(*args)

def QCLog_Find(publicID):
    r"""QCLog_Find(std::string const & publicID) -> QCLog"""
    return _datamodel.QCLog_Find(publicID)

class WaveformQualityIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::WaveformQualityIndex 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__(WaveformQualityIndex self) -> WaveformQualityIndex
        __init__(WaveformQualityIndex self, Time start, WaveformStreamID waveformID, std::string const & type, std::string const & parameter) -> WaveformQualityIndex
        __init__(WaveformQualityIndex self, WaveformQualityIndex arg2) -> WaveformQualityIndex
        """
        _datamodel.WaveformQualityIndex_swiginit(self, _datamodel.new_WaveformQualityIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(WaveformQualityIndex self, WaveformQualityIndex arg2) -> bool"""
        return _datamodel.WaveformQualityIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(WaveformQualityIndex self, WaveformQualityIndex arg2) -> bool"""
        return _datamodel.WaveformQualityIndex___ne__(self, arg2)
    start = property(_datamodel.WaveformQualityIndex_start_get, _datamodel.WaveformQualityIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    waveformID = property(_datamodel.WaveformQualityIndex_waveformID_get, _datamodel.WaveformQualityIndex_waveformID_set, doc=r"""waveformID : Seiscomp::DataModel::WaveformStreamID""")
    type = property(_datamodel.WaveformQualityIndex_type_get, _datamodel.WaveformQualityIndex_type_set, doc=r"""type : std::string""")
    parameter = property(_datamodel.WaveformQualityIndex_parameter_get, _datamodel.WaveformQualityIndex_parameter_set, doc=r"""parameter : std::string""")
    __swig_destroy__ = _datamodel.delete_WaveformQualityIndex

# Register WaveformQualityIndex in _datamodel:
_datamodel.WaveformQualityIndex_swigregister(WaveformQualityIndex)

class WaveformQuality(Object):
    r"""Proxy of C++ Seiscomp::DataModel::WaveformQuality 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 _datamodel.WaveformQuality_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.WaveformQuality_TypeInfo()

    def className(self):
        r"""className(WaveformQuality self) -> char const *"""
        return _datamodel.WaveformQuality_className(self)

    def typeInfo(self):
        r"""typeInfo(WaveformQuality self) -> RTTI"""
        return _datamodel.WaveformQuality_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> WaveformQuality
        Cast(Seiscomp::Core::BaseObjectPtr o) -> WaveformQuality
        """
        return _datamodel.WaveformQuality_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> WaveformQuality
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> WaveformQuality
        """
        return _datamodel.WaveformQuality_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(WaveformQuality self, GenericArchive ar)"""
        return _datamodel.WaveformQuality_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.WaveformQuality_Meta()

    def meta(self):
        r"""meta(WaveformQuality self) -> MetaObject"""
        return _datamodel.WaveformQuality_meta(self)

    def __init__(self, *args):
        r"""
        __init__(WaveformQuality self) -> WaveformQuality
        __init__(WaveformQuality self, WaveformQuality other) -> WaveformQuality
        """
        _datamodel.WaveformQuality_swiginit(self, _datamodel.new_WaveformQuality(*args))
    __swig_destroy__ = _datamodel.delete_WaveformQuality

    def __eq__(self, other):
        r"""__eq__(WaveformQuality self, WaveformQuality other) -> bool"""
        return _datamodel.WaveformQuality___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(WaveformQuality self, WaveformQuality other) -> bool"""
        return _datamodel.WaveformQuality___ne__(self, other)

    def equal(self, other):
        r"""equal(WaveformQuality self, WaveformQuality other) -> bool"""
        return _datamodel.WaveformQuality_equal(self, other)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(WaveformQuality self, WaveformStreamID waveformID)"""
        return _datamodel.WaveformQuality_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(WaveformQuality self) -> WaveformStreamID
        waveformID(WaveformQuality self) -> WaveformStreamID
        """
        return _datamodel.WaveformQuality_waveformID(self, *args)

    def setCreatorID(self, creatorID):
        r"""setCreatorID(WaveformQuality self, std::string const & creatorID)"""
        return _datamodel.WaveformQuality_setCreatorID(self, creatorID)

    def creatorID(self):
        r"""creatorID(WaveformQuality self) -> std::string const &"""
        return _datamodel.WaveformQuality_creatorID(self)

    def setCreated(self, created):
        r"""setCreated(WaveformQuality self, Time created)"""
        return _datamodel.WaveformQuality_setCreated(self, created)

    def created(self):
        r"""created(WaveformQuality self) -> Time"""
        return _datamodel.WaveformQuality_created(self)

    def setStart(self, start):
        r"""setStart(WaveformQuality self, Time start)"""
        return _datamodel.WaveformQuality_setStart(self, start)

    def start(self):
        r"""start(WaveformQuality self) -> Time"""
        return _datamodel.WaveformQuality_start(self)

    def setEnd(self, end):
        r"""setEnd(WaveformQuality self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.WaveformQuality_setEnd(self, end)

    def end(self):
        r"""end(WaveformQuality self) -> Time"""
        return _datamodel.WaveformQuality_end(self)

    def setType(self, type):
        r"""setType(WaveformQuality self, std::string const & type)"""
        return _datamodel.WaveformQuality_setType(self, type)

    def type(self):
        r"""type(WaveformQuality self) -> std::string const &"""
        return _datamodel.WaveformQuality_type(self)

    def setParameter(self, parameter):
        r"""setParameter(WaveformQuality self, std::string const & parameter)"""
        return _datamodel.WaveformQuality_setParameter(self, parameter)

    def parameter(self):
        r"""parameter(WaveformQuality self) -> std::string const &"""
        return _datamodel.WaveformQuality_parameter(self)

    def setValue(self, value):
        r"""setValue(WaveformQuality self, double value)"""
        return _datamodel.WaveformQuality_setValue(self, value)

    def value(self):
        r"""value(WaveformQuality self) -> double"""
        return _datamodel.WaveformQuality_value(self)

    def setLowerUncertainty(self, lowerUncertainty):
        r"""setLowerUncertainty(WaveformQuality self, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty)"""
        return _datamodel.WaveformQuality_setLowerUncertainty(self, lowerUncertainty)

    def lowerUncertainty(self):
        r"""lowerUncertainty(WaveformQuality self) -> double"""
        return _datamodel.WaveformQuality_lowerUncertainty(self)

    def setUpperUncertainty(self, upperUncertainty):
        r"""setUpperUncertainty(WaveformQuality self, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty)"""
        return _datamodel.WaveformQuality_setUpperUncertainty(self, upperUncertainty)

    def upperUncertainty(self):
        r"""upperUncertainty(WaveformQuality self) -> double"""
        return _datamodel.WaveformQuality_upperUncertainty(self)

    def setWindowLength(self, windowLength):
        r"""setWindowLength(WaveformQuality self, Seiscomp::Core::Optional< double >::Impl const & windowLength)"""
        return _datamodel.WaveformQuality_setWindowLength(self, windowLength)

    def windowLength(self):
        r"""windowLength(WaveformQuality self) -> double"""
        return _datamodel.WaveformQuality_windowLength(self)

    def index(self):
        r"""index(WaveformQuality self) -> WaveformQualityIndex"""
        return _datamodel.WaveformQuality_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(WaveformQuality self, WaveformQuality lhs) -> bool"""
        return _datamodel.WaveformQuality_equalIndex(self, lhs)

    def qualityControl(self):
        r"""qualityControl(WaveformQuality self) -> QualityControl"""
        return _datamodel.WaveformQuality_qualityControl(self)

    def assign(self, other):
        r"""assign(WaveformQuality self, Object other) -> bool"""
        return _datamodel.WaveformQuality_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(WaveformQuality self, PublicObject parent) -> bool"""
        return _datamodel.WaveformQuality_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(WaveformQuality self, PublicObject parent) -> bool"""
        return _datamodel.WaveformQuality_detachFrom(self, parent)

    def detach(self):
        r"""detach(WaveformQuality self) -> bool"""
        return _datamodel.WaveformQuality_detach(self)

    def clone(self):
        r"""clone(WaveformQuality self) -> Object"""
        return _datamodel.WaveformQuality_clone(self)

    def accept(self, visitor):
        r"""accept(WaveformQuality self, Visitor visitor)"""
        return _datamodel.WaveformQuality_accept(self, visitor)

# Register WaveformQuality in _datamodel:
_datamodel.WaveformQuality_swigregister(WaveformQuality)

def WaveformQuality_ClassName():
    r"""WaveformQuality_ClassName() -> char const *"""
    return _datamodel.WaveformQuality_ClassName()

def WaveformQuality_TypeInfo():
    r"""WaveformQuality_TypeInfo() -> RTTI"""
    return _datamodel.WaveformQuality_TypeInfo()

def WaveformQuality_Cast(*args):
    r"""
    WaveformQuality_Cast(BaseObject o) -> WaveformQuality
    WaveformQuality_Cast(Seiscomp::Core::BaseObjectPtr o) -> WaveformQuality
    """
    return _datamodel.WaveformQuality_Cast(*args)

def WaveformQuality_ConstCast(*args):
    r"""
    WaveformQuality_ConstCast(BaseObject o) -> WaveformQuality
    WaveformQuality_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> WaveformQuality
    """
    return _datamodel.WaveformQuality_ConstCast(*args)

def WaveformQuality_Meta():
    r"""WaveformQuality_Meta() -> MetaObject"""
    return _datamodel.WaveformQuality_Meta()

class OutageIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::OutageIndex 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__(OutageIndex self) -> OutageIndex
        __init__(OutageIndex self, WaveformStreamID waveformID, Time start) -> OutageIndex
        __init__(OutageIndex self, OutageIndex arg2) -> OutageIndex
        """
        _datamodel.OutageIndex_swiginit(self, _datamodel.new_OutageIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(OutageIndex self, OutageIndex arg2) -> bool"""
        return _datamodel.OutageIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(OutageIndex self, OutageIndex arg2) -> bool"""
        return _datamodel.OutageIndex___ne__(self, arg2)
    waveformID = property(_datamodel.OutageIndex_waveformID_get, _datamodel.OutageIndex_waveformID_set, doc=r"""waveformID : Seiscomp::DataModel::WaveformStreamID""")
    start = property(_datamodel.OutageIndex_start_get, _datamodel.OutageIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_OutageIndex

# Register OutageIndex in _datamodel:
_datamodel.OutageIndex_swigregister(OutageIndex)

class Outage(Object):
    r"""Proxy of C++ Seiscomp::DataModel::Outage 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 _datamodel.Outage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Outage_TypeInfo()

    def className(self):
        r"""className(Outage self) -> char const *"""
        return _datamodel.Outage_className(self)

    def typeInfo(self):
        r"""typeInfo(Outage self) -> RTTI"""
        return _datamodel.Outage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Outage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Outage
        """
        return _datamodel.Outage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Outage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Outage
        """
        return _datamodel.Outage_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Outage self, GenericArchive ar)"""
        return _datamodel.Outage_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Outage_Meta()

    def meta(self):
        r"""meta(Outage self) -> MetaObject"""
        return _datamodel.Outage_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Outage self) -> Outage
        __init__(Outage self, Outage other) -> Outage
        """
        _datamodel.Outage_swiginit(self, _datamodel.new_Outage(*args))
    __swig_destroy__ = _datamodel.delete_Outage

    def __eq__(self, other):
        r"""__eq__(Outage self, Outage other) -> bool"""
        return _datamodel.Outage___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Outage self, Outage other) -> bool"""
        return _datamodel.Outage___ne__(self, other)

    def equal(self, other):
        r"""equal(Outage self, Outage other) -> bool"""
        return _datamodel.Outage_equal(self, other)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(Outage self, WaveformStreamID waveformID)"""
        return _datamodel.Outage_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(Outage self) -> WaveformStreamID
        waveformID(Outage self) -> WaveformStreamID
        """
        return _datamodel.Outage_waveformID(self, *args)

    def setCreatorID(self, creatorID):
        r"""setCreatorID(Outage self, std::string const & creatorID)"""
        return _datamodel.Outage_setCreatorID(self, creatorID)

    def creatorID(self):
        r"""creatorID(Outage self) -> std::string const &"""
        return _datamodel.Outage_creatorID(self)

    def setCreated(self, created):
        r"""setCreated(Outage self, Time created)"""
        return _datamodel.Outage_setCreated(self, created)

    def created(self):
        r"""created(Outage self) -> Time"""
        return _datamodel.Outage_created(self)

    def setStart(self, start):
        r"""setStart(Outage self, Time start)"""
        return _datamodel.Outage_setStart(self, start)

    def start(self):
        r"""start(Outage self) -> Time"""
        return _datamodel.Outage_start(self)

    def setEnd(self, end):
        r"""setEnd(Outage self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.Outage_setEnd(self, end)

    def end(self):
        r"""end(Outage self) -> Time"""
        return _datamodel.Outage_end(self)

    def index(self):
        r"""index(Outage self) -> OutageIndex"""
        return _datamodel.Outage_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Outage self, Outage lhs) -> bool"""
        return _datamodel.Outage_equalIndex(self, lhs)

    def qualityControl(self):
        r"""qualityControl(Outage self) -> QualityControl"""
        return _datamodel.Outage_qualityControl(self)

    def assign(self, other):
        r"""assign(Outage self, Object other) -> bool"""
        return _datamodel.Outage_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Outage self, PublicObject parent) -> bool"""
        return _datamodel.Outage_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Outage self, PublicObject parent) -> bool"""
        return _datamodel.Outage_detachFrom(self, parent)

    def detach(self):
        r"""detach(Outage self) -> bool"""
        return _datamodel.Outage_detach(self)

    def clone(self):
        r"""clone(Outage self) -> Object"""
        return _datamodel.Outage_clone(self)

    def accept(self, visitor):
        r"""accept(Outage self, Visitor visitor)"""
        return _datamodel.Outage_accept(self, visitor)

# Register Outage in _datamodel:
_datamodel.Outage_swigregister(Outage)

def Outage_ClassName():
    r"""Outage_ClassName() -> char const *"""
    return _datamodel.Outage_ClassName()

def Outage_TypeInfo():
    r"""Outage_TypeInfo() -> RTTI"""
    return _datamodel.Outage_TypeInfo()

def Outage_Cast(*args):
    r"""
    Outage_Cast(BaseObject o) -> Outage
    Outage_Cast(Seiscomp::Core::BaseObjectPtr o) -> Outage
    """
    return _datamodel.Outage_Cast(*args)

def Outage_ConstCast(*args):
    r"""
    Outage_ConstCast(BaseObject o) -> Outage
    Outage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Outage
    """
    return _datamodel.Outage_ConstCast(*args)

def Outage_Meta():
    r"""Outage_Meta() -> MetaObject"""
    return _datamodel.Outage_Meta()

class QualityControl(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::QualityControl 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 _datamodel.QualityControl_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.QualityControl_TypeInfo()

    def className(self):
        r"""className(QualityControl self) -> char const *"""
        return _datamodel.QualityControl_className(self)

    def typeInfo(self):
        r"""typeInfo(QualityControl self) -> RTTI"""
        return _datamodel.QualityControl_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> QualityControl
        Cast(Seiscomp::Core::BaseObjectPtr o) -> QualityControl
        """
        return _datamodel.QualityControl_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> QualityControl
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> QualityControl
        """
        return _datamodel.QualityControl_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(QualityControl self, GenericArchive ar)"""
        return _datamodel.QualityControl_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.QualityControl_Meta()

    def meta(self):
        r"""meta(QualityControl self) -> MetaObject"""
        return _datamodel.QualityControl_meta(self)

    def __init__(self, *args):
        r"""
        __init__(QualityControl self) -> QualityControl
        __init__(QualityControl self, QualityControl other) -> QualityControl
        """
        _datamodel.QualityControl_swiginit(self, _datamodel.new_QualityControl(*args))
    __swig_destroy__ = _datamodel.delete_QualityControl

    def __eq__(self, other):
        r"""__eq__(QualityControl self, QualityControl other) -> bool"""
        return _datamodel.QualityControl___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(QualityControl self, QualityControl other) -> bool"""
        return _datamodel.QualityControl___ne__(self, other)

    def equal(self, other):
        r"""equal(QualityControl self, QualityControl other) -> bool"""
        return _datamodel.QualityControl_equal(self, other)

    def add(self, *args):
        r"""
        add(QualityControl self, QCLog obj) -> bool
        add(QualityControl self, WaveformQuality obj) -> bool
        add(QualityControl self, Outage obj) -> bool
        """
        return _datamodel.QualityControl_add(self, *args)

    def remove(self, *args):
        r"""
        remove(QualityControl self, QCLog obj) -> bool
        remove(QualityControl self, WaveformQuality obj) -> bool
        remove(QualityControl self, Outage obj) -> bool
        """
        return _datamodel.QualityControl_remove(self, *args)

    def removeQCLog(self, *args):
        r"""
        removeQCLog(QualityControl self, size_t i) -> bool
        removeQCLog(QualityControl self, QCLogIndex i) -> bool
        """
        return _datamodel.QualityControl_removeQCLog(self, *args)

    def removeWaveformQuality(self, *args):
        r"""
        removeWaveformQuality(QualityControl self, size_t i) -> bool
        removeWaveformQuality(QualityControl self, WaveformQualityIndex i) -> bool
        """
        return _datamodel.QualityControl_removeWaveformQuality(self, *args)

    def removeOutage(self, *args):
        r"""
        removeOutage(QualityControl self, size_t i) -> bool
        removeOutage(QualityControl self, OutageIndex i) -> bool
        """
        return _datamodel.QualityControl_removeOutage(self, *args)

    def qCLogCount(self):
        r"""qCLogCount(QualityControl self) -> size_t"""
        return _datamodel.QualityControl_qCLogCount(self)

    def waveformQualityCount(self):
        r"""waveformQualityCount(QualityControl self) -> size_t"""
        return _datamodel.QualityControl_waveformQualityCount(self)

    def outageCount(self):
        r"""outageCount(QualityControl self) -> size_t"""
        return _datamodel.QualityControl_outageCount(self)

    def qCLog(self, *args):
        r"""
        qCLog(QualityControl self, size_t i) -> QCLog
        qCLog(QualityControl self, QCLogIndex i) -> QCLog
        """
        return _datamodel.QualityControl_qCLog(self, *args)

    def waveformQuality(self, *args):
        r"""
        waveformQuality(QualityControl self, size_t i) -> WaveformQuality
        waveformQuality(QualityControl self, WaveformQualityIndex i) -> WaveformQuality
        """
        return _datamodel.QualityControl_waveformQuality(self, *args)

    def outage(self, *args):
        r"""
        outage(QualityControl self, size_t i) -> Outage
        outage(QualityControl self, OutageIndex i) -> Outage
        """
        return _datamodel.QualityControl_outage(self, *args)

    def findQCLog(self, publicID):
        r"""findQCLog(QualityControl self, std::string const & publicID) -> QCLog"""
        return _datamodel.QualityControl_findQCLog(self, publicID)

    def assign(self, other):
        r"""assign(QualityControl self, Object other) -> bool"""
        return _datamodel.QualityControl_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(QualityControl self, PublicObject parent) -> bool"""
        return _datamodel.QualityControl_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(QualityControl self, PublicObject parent) -> bool"""
        return _datamodel.QualityControl_detachFrom(self, parent)

    def detach(self):
        r"""detach(QualityControl self) -> bool"""
        return _datamodel.QualityControl_detach(self)

    def clone(self):
        r"""clone(QualityControl self) -> Object"""
        return _datamodel.QualityControl_clone(self)

    def updateChild(self, child):
        r"""updateChild(QualityControl self, Object child) -> bool"""
        return _datamodel.QualityControl_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(QualityControl self, Visitor visitor)"""
        return _datamodel.QualityControl_accept(self, visitor)

# Register QualityControl in _datamodel:
_datamodel.QualityControl_swigregister(QualityControl)

def QualityControl_ClassName():
    r"""QualityControl_ClassName() -> char const *"""
    return _datamodel.QualityControl_ClassName()

def QualityControl_TypeInfo():
    r"""QualityControl_TypeInfo() -> RTTI"""
    return _datamodel.QualityControl_TypeInfo()

def QualityControl_Cast(*args):
    r"""
    QualityControl_Cast(BaseObject o) -> QualityControl
    QualityControl_Cast(Seiscomp::Core::BaseObjectPtr o) -> QualityControl
    """
    return _datamodel.QualityControl_Cast(*args)

def QualityControl_ConstCast(*args):
    r"""
    QualityControl_ConstCast(BaseObject o) -> QualityControl
    QualityControl_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> QualityControl
    """
    return _datamodel.QualityControl_ConstCast(*args)

def QualityControl_Meta():
    r"""QualityControl_Meta() -> MetaObject"""
    return _datamodel.QualityControl_Meta()

class StationReferenceIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::StationReferenceIndex 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__(StationReferenceIndex self) -> StationReferenceIndex
        __init__(StationReferenceIndex self, std::string const & stationID) -> StationReferenceIndex
        __init__(StationReferenceIndex self, StationReferenceIndex arg2) -> StationReferenceIndex
        """
        _datamodel.StationReferenceIndex_swiginit(self, _datamodel.new_StationReferenceIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(StationReferenceIndex self, StationReferenceIndex arg2) -> bool"""
        return _datamodel.StationReferenceIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(StationReferenceIndex self, StationReferenceIndex arg2) -> bool"""
        return _datamodel.StationReferenceIndex___ne__(self, arg2)
    stationID = property(_datamodel.StationReferenceIndex_stationID_get, _datamodel.StationReferenceIndex_stationID_set, doc=r"""stationID : std::string""")
    __swig_destroy__ = _datamodel.delete_StationReferenceIndex

# Register StationReferenceIndex in _datamodel:
_datamodel.StationReferenceIndex_swigregister(StationReferenceIndex)

class StationReference(Object):
    r"""Proxy of C++ Seiscomp::DataModel::StationReference 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 _datamodel.StationReference_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.StationReference_TypeInfo()

    def className(self):
        r"""className(StationReference self) -> char const *"""
        return _datamodel.StationReference_className(self)

    def typeInfo(self):
        r"""typeInfo(StationReference self) -> RTTI"""
        return _datamodel.StationReference_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> StationReference
        Cast(Seiscomp::Core::BaseObjectPtr o) -> StationReference
        """
        return _datamodel.StationReference_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> StationReference
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationReference
        """
        return _datamodel.StationReference_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(StationReference self, GenericArchive ar)"""
        return _datamodel.StationReference_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.StationReference_Meta()

    def meta(self):
        r"""meta(StationReference self) -> MetaObject"""
        return _datamodel.StationReference_meta(self)

    def __init__(self, *args):
        r"""
        __init__(StationReference self) -> StationReference
        __init__(StationReference self, StationReference other) -> StationReference
        __init__(StationReference self, std::string const & stationID) -> StationReference
        """
        _datamodel.StationReference_swiginit(self, _datamodel.new_StationReference(*args))
    __swig_destroy__ = _datamodel.delete_StationReference

    def __eq__(self, other):
        r"""__eq__(StationReference self, StationReference other) -> bool"""
        return _datamodel.StationReference___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(StationReference self, StationReference other) -> bool"""
        return _datamodel.StationReference___ne__(self, other)

    def equal(self, other):
        r"""equal(StationReference self, StationReference other) -> bool"""
        return _datamodel.StationReference_equal(self, other)

    def setStationID(self, stationID):
        r"""setStationID(StationReference self, std::string const & stationID)"""
        return _datamodel.StationReference_setStationID(self, stationID)

    def stationID(self):
        r"""stationID(StationReference self) -> std::string const &"""
        return _datamodel.StationReference_stationID(self)

    def index(self):
        r"""index(StationReference self) -> StationReferenceIndex"""
        return _datamodel.StationReference_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(StationReference self, StationReference lhs) -> bool"""
        return _datamodel.StationReference_equalIndex(self, lhs)

    def stationGroup(self):
        r"""stationGroup(StationReference self) -> StationGroup"""
        return _datamodel.StationReference_stationGroup(self)

    def assign(self, other):
        r"""assign(StationReference self, Object other) -> bool"""
        return _datamodel.StationReference_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(StationReference self, PublicObject parent) -> bool"""
        return _datamodel.StationReference_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(StationReference self, PublicObject parent) -> bool"""
        return _datamodel.StationReference_detachFrom(self, parent)

    def detach(self):
        r"""detach(StationReference self) -> bool"""
        return _datamodel.StationReference_detach(self)

    def clone(self):
        r"""clone(StationReference self) -> Object"""
        return _datamodel.StationReference_clone(self)

    def accept(self, visitor):
        r"""accept(StationReference self, Visitor visitor)"""
        return _datamodel.StationReference_accept(self, visitor)

# Register StationReference in _datamodel:
_datamodel.StationReference_swigregister(StationReference)

def StationReference_ClassName():
    r"""StationReference_ClassName() -> char const *"""
    return _datamodel.StationReference_ClassName()

def StationReference_TypeInfo():
    r"""StationReference_TypeInfo() -> RTTI"""
    return _datamodel.StationReference_TypeInfo()

def StationReference_Cast(*args):
    r"""
    StationReference_Cast(BaseObject o) -> StationReference
    StationReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> StationReference
    """
    return _datamodel.StationReference_Cast(*args)

def StationReference_ConstCast(*args):
    r"""
    StationReference_ConstCast(BaseObject o) -> StationReference
    StationReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationReference
    """
    return _datamodel.StationReference_ConstCast(*args)

def StationReference_Meta():
    r"""StationReference_Meta() -> MetaObject"""
    return _datamodel.StationReference_Meta()

class StationGroupIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::StationGroupIndex 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__(StationGroupIndex self) -> StationGroupIndex
        __init__(StationGroupIndex self, std::string const & code) -> StationGroupIndex
        __init__(StationGroupIndex self, StationGroupIndex arg2) -> StationGroupIndex
        """
        _datamodel.StationGroupIndex_swiginit(self, _datamodel.new_StationGroupIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(StationGroupIndex self, StationGroupIndex arg2) -> bool"""
        return _datamodel.StationGroupIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(StationGroupIndex self, StationGroupIndex arg2) -> bool"""
        return _datamodel.StationGroupIndex___ne__(self, arg2)
    code = property(_datamodel.StationGroupIndex_code_get, _datamodel.StationGroupIndex_code_set, doc=r"""code : std::string""")
    __swig_destroy__ = _datamodel.delete_StationGroupIndex

# Register StationGroupIndex in _datamodel:
_datamodel.StationGroupIndex_swigregister(StationGroupIndex)

class StationGroup(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::StationGroup 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 _datamodel.StationGroup_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.StationGroup_TypeInfo()

    def className(self):
        r"""className(StationGroup self) -> char const *"""
        return _datamodel.StationGroup_className(self)

    def typeInfo(self):
        r"""typeInfo(StationGroup self) -> RTTI"""
        return _datamodel.StationGroup_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> StationGroup
        Cast(Seiscomp::Core::BaseObjectPtr o) -> StationGroup
        """
        return _datamodel.StationGroup_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> StationGroup
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationGroup
        """
        return _datamodel.StationGroup_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(StationGroup self, GenericArchive ar)"""
        return _datamodel.StationGroup_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.StationGroup_Meta()

    def meta(self):
        r"""meta(StationGroup self) -> MetaObject"""
        return _datamodel.StationGroup_meta(self)

    def __init__(self, *args):
        r"""
        __init__(StationGroup self, StationGroup other) -> StationGroup
        __init__(StationGroup self, std::string const & publicID) -> StationGroup
        """
        _datamodel.StationGroup_swiginit(self, _datamodel.new_StationGroup(*args))
    __swig_destroy__ = _datamodel.delete_StationGroup

    @staticmethod
    def Create(*args):
        r"""
        Create() -> StationGroup
        Create(std::string const & publicID) -> StationGroup
        """
        return _datamodel.StationGroup_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> StationGroup"""
        return _datamodel.StationGroup_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(StationGroup self, StationGroup other) -> bool"""
        return _datamodel.StationGroup___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(StationGroup self, StationGroup other) -> bool"""
        return _datamodel.StationGroup___ne__(self, other)

    def equal(self, other):
        r"""equal(StationGroup self, StationGroup other) -> bool"""
        return _datamodel.StationGroup_equal(self, other)

    def setType(self, type):
        r"""setType(StationGroup self, Seiscomp::Core::Optional< Seiscomp::DataModel::StationGroupType >::Impl const & type)"""
        return _datamodel.StationGroup_setType(self, type)

    def type(self):
        r"""type(StationGroup self) -> Seiscomp::DataModel::StationGroupType"""
        return _datamodel.StationGroup_type(self)

    def setCode(self, code):
        r"""setCode(StationGroup self, std::string const & code)"""
        return _datamodel.StationGroup_setCode(self, code)

    def code(self):
        r"""code(StationGroup self) -> std::string const &"""
        return _datamodel.StationGroup_code(self)

    def setStart(self, start):
        r"""setStart(StationGroup self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & start)"""
        return _datamodel.StationGroup_setStart(self, start)

    def start(self):
        r"""start(StationGroup self) -> Time"""
        return _datamodel.StationGroup_start(self)

    def setEnd(self, end):
        r"""setEnd(StationGroup self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.StationGroup_setEnd(self, end)

    def end(self):
        r"""end(StationGroup self) -> Time"""
        return _datamodel.StationGroup_end(self)

    def setDescription(self, description):
        r"""setDescription(StationGroup self, std::string const & description)"""
        return _datamodel.StationGroup_setDescription(self, description)

    def description(self):
        r"""description(StationGroup self) -> std::string const &"""
        return _datamodel.StationGroup_description(self)

    def setLatitude(self, latitude):
        r"""setLatitude(StationGroup self, Seiscomp::Core::Optional< double >::Impl const & latitude)"""
        return _datamodel.StationGroup_setLatitude(self, latitude)

    def latitude(self):
        r"""latitude(StationGroup self) -> double"""
        return _datamodel.StationGroup_latitude(self)

    def setLongitude(self, longitude):
        r"""setLongitude(StationGroup self, Seiscomp::Core::Optional< double >::Impl const & longitude)"""
        return _datamodel.StationGroup_setLongitude(self, longitude)

    def longitude(self):
        r"""longitude(StationGroup self) -> double"""
        return _datamodel.StationGroup_longitude(self)

    def setElevation(self, elevation):
        r"""setElevation(StationGroup self, Seiscomp::Core::Optional< double >::Impl const & elevation)"""
        return _datamodel.StationGroup_setElevation(self, elevation)

    def elevation(self):
        r"""elevation(StationGroup self) -> double"""
        return _datamodel.StationGroup_elevation(self)

    def index(self):
        r"""index(StationGroup self) -> StationGroupIndex"""
        return _datamodel.StationGroup_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(StationGroup self, StationGroup lhs) -> bool"""
        return _datamodel.StationGroup_equalIndex(self, lhs)

    def add(self, obj):
        r"""add(StationGroup self, StationReference obj) -> bool"""
        return _datamodel.StationGroup_add(self, obj)

    def remove(self, obj):
        r"""remove(StationGroup self, StationReference obj) -> bool"""
        return _datamodel.StationGroup_remove(self, obj)

    def removeStationReference(self, *args):
        r"""
        removeStationReference(StationGroup self, size_t i) -> bool
        removeStationReference(StationGroup self, StationReferenceIndex i) -> bool
        """
        return _datamodel.StationGroup_removeStationReference(self, *args)

    def stationReferenceCount(self):
        r"""stationReferenceCount(StationGroup self) -> size_t"""
        return _datamodel.StationGroup_stationReferenceCount(self)

    def stationReference(self, *args):
        r"""
        stationReference(StationGroup self, size_t i) -> StationReference
        stationReference(StationGroup self, StationReferenceIndex i) -> StationReference
        """
        return _datamodel.StationGroup_stationReference(self, *args)

    def inventory(self):
        r"""inventory(StationGroup self) -> Inventory"""
        return _datamodel.StationGroup_inventory(self)

    def assign(self, other):
        r"""assign(StationGroup self, Object other) -> bool"""
        return _datamodel.StationGroup_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(StationGroup self, PublicObject parent) -> bool"""
        return _datamodel.StationGroup_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(StationGroup self, PublicObject parent) -> bool"""
        return _datamodel.StationGroup_detachFrom(self, parent)

    def detach(self):
        r"""detach(StationGroup self) -> bool"""
        return _datamodel.StationGroup_detach(self)

    def clone(self):
        r"""clone(StationGroup self) -> Object"""
        return _datamodel.StationGroup_clone(self)

    def updateChild(self, child):
        r"""updateChild(StationGroup self, Object child) -> bool"""
        return _datamodel.StationGroup_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(StationGroup self, Visitor visitor)"""
        return _datamodel.StationGroup_accept(self, visitor)

# Register StationGroup in _datamodel:
_datamodel.StationGroup_swigregister(StationGroup)

def StationGroup_ClassName():
    r"""StationGroup_ClassName() -> char const *"""
    return _datamodel.StationGroup_ClassName()

def StationGroup_TypeInfo():
    r"""StationGroup_TypeInfo() -> RTTI"""
    return _datamodel.StationGroup_TypeInfo()

def StationGroup_Cast(*args):
    r"""
    StationGroup_Cast(BaseObject o) -> StationGroup
    StationGroup_Cast(Seiscomp::Core::BaseObjectPtr o) -> StationGroup
    """
    return _datamodel.StationGroup_Cast(*args)

def StationGroup_ConstCast(*args):
    r"""
    StationGroup_ConstCast(BaseObject o) -> StationGroup
    StationGroup_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationGroup
    """
    return _datamodel.StationGroup_ConstCast(*args)

def StationGroup_Meta():
    r"""StationGroup_Meta() -> MetaObject"""
    return _datamodel.StationGroup_Meta()

def StationGroup_Create(*args):
    r"""
    StationGroup_Create() -> StationGroup
    StationGroup_Create(std::string const & publicID) -> StationGroup
    """
    return _datamodel.StationGroup_Create(*args)

def StationGroup_Find(publicID):
    r"""StationGroup_Find(std::string const & publicID) -> StationGroup"""
    return _datamodel.StationGroup_Find(publicID)

class AuxSourceIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::AuxSourceIndex 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__(AuxSourceIndex self) -> AuxSourceIndex
        __init__(AuxSourceIndex self, std::string const & name) -> AuxSourceIndex
        __init__(AuxSourceIndex self, AuxSourceIndex arg2) -> AuxSourceIndex
        """
        _datamodel.AuxSourceIndex_swiginit(self, _datamodel.new_AuxSourceIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(AuxSourceIndex self, AuxSourceIndex arg2) -> bool"""
        return _datamodel.AuxSourceIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(AuxSourceIndex self, AuxSourceIndex arg2) -> bool"""
        return _datamodel.AuxSourceIndex___ne__(self, arg2)
    name = property(_datamodel.AuxSourceIndex_name_get, _datamodel.AuxSourceIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_AuxSourceIndex

# Register AuxSourceIndex in _datamodel:
_datamodel.AuxSourceIndex_swigregister(AuxSourceIndex)

class AuxSource(Object):
    r"""Proxy of C++ Seiscomp::DataModel::AuxSource 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 _datamodel.AuxSource_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.AuxSource_TypeInfo()

    def className(self):
        r"""className(AuxSource self) -> char const *"""
        return _datamodel.AuxSource_className(self)

    def typeInfo(self):
        r"""typeInfo(AuxSource self) -> RTTI"""
        return _datamodel.AuxSource_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> AuxSource
        Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxSource
        """
        return _datamodel.AuxSource_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> AuxSource
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxSource
        """
        return _datamodel.AuxSource_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(AuxSource self, GenericArchive ar)"""
        return _datamodel.AuxSource_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.AuxSource_Meta()

    def meta(self):
        r"""meta(AuxSource self) -> MetaObject"""
        return _datamodel.AuxSource_meta(self)

    def __init__(self, *args):
        r"""
        __init__(AuxSource self) -> AuxSource
        __init__(AuxSource self, AuxSource other) -> AuxSource
        __init__(AuxSource self, std::string const & name) -> AuxSource
        __init__(AuxSource self, std::string const & name, std::string const & description, std::string const & unit, std::string const & conversion, Seiscomp::Core::Optional< int >::Impl const & sampleRateNumerator=Unset, Seiscomp::Core::Optional< int >::Impl const & sampleRateDenominator=Unset, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark=Unset) -> AuxSource
        """
        _datamodel.AuxSource_swiginit(self, _datamodel.new_AuxSource(*args))
    __swig_destroy__ = _datamodel.delete_AuxSource

    def __eq__(self, other):
        r"""__eq__(AuxSource self, AuxSource other) -> bool"""
        return _datamodel.AuxSource___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(AuxSource self, AuxSource other) -> bool"""
        return _datamodel.AuxSource___ne__(self, other)

    def equal(self, other):
        r"""equal(AuxSource self, AuxSource other) -> bool"""
        return _datamodel.AuxSource_equal(self, other)

    def setName(self, name):
        r"""setName(AuxSource self, std::string const & name)"""
        return _datamodel.AuxSource_setName(self, name)

    def name(self):
        r"""name(AuxSource self) -> std::string const &"""
        return _datamodel.AuxSource_name(self)

    def setDescription(self, description):
        r"""setDescription(AuxSource self, std::string const & description)"""
        return _datamodel.AuxSource_setDescription(self, description)

    def description(self):
        r"""description(AuxSource self) -> std::string const &"""
        return _datamodel.AuxSource_description(self)

    def setUnit(self, unit):
        r"""setUnit(AuxSource self, std::string const & unit)"""
        return _datamodel.AuxSource_setUnit(self, unit)

    def unit(self):
        r"""unit(AuxSource self) -> std::string const &"""
        return _datamodel.AuxSource_unit(self)

    def setConversion(self, conversion):
        r"""setConversion(AuxSource self, std::string const & conversion)"""
        return _datamodel.AuxSource_setConversion(self, conversion)

    def conversion(self):
        r"""conversion(AuxSource self) -> std::string const &"""
        return _datamodel.AuxSource_conversion(self)

    def setSampleRateNumerator(self, sampleRateNumerator):
        r"""setSampleRateNumerator(AuxSource self, Seiscomp::Core::Optional< int >::Impl const & sampleRateNumerator)"""
        return _datamodel.AuxSource_setSampleRateNumerator(self, sampleRateNumerator)

    def sampleRateNumerator(self):
        r"""sampleRateNumerator(AuxSource self) -> int"""
        return _datamodel.AuxSource_sampleRateNumerator(self)

    def setSampleRateDenominator(self, sampleRateDenominator):
        r"""setSampleRateDenominator(AuxSource self, Seiscomp::Core::Optional< int >::Impl const & sampleRateDenominator)"""
        return _datamodel.AuxSource_setSampleRateDenominator(self, sampleRateDenominator)

    def sampleRateDenominator(self):
        r"""sampleRateDenominator(AuxSource self) -> int"""
        return _datamodel.AuxSource_sampleRateDenominator(self)

    def setRemark(self, remark):
        r"""setRemark(AuxSource self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.AuxSource_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(AuxSource self) -> Blob
        remark(AuxSource self) -> Blob
        """
        return _datamodel.AuxSource_remark(self, *args)

    def index(self):
        r"""index(AuxSource self) -> AuxSourceIndex"""
        return _datamodel.AuxSource_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(AuxSource self, AuxSource lhs) -> bool"""
        return _datamodel.AuxSource_equalIndex(self, lhs)

    def auxDevice(self):
        r"""auxDevice(AuxSource self) -> AuxDevice"""
        return _datamodel.AuxSource_auxDevice(self)

    def assign(self, other):
        r"""assign(AuxSource self, Object other) -> bool"""
        return _datamodel.AuxSource_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(AuxSource self, PublicObject parent) -> bool"""
        return _datamodel.AuxSource_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(AuxSource self, PublicObject parent) -> bool"""
        return _datamodel.AuxSource_detachFrom(self, parent)

    def detach(self):
        r"""detach(AuxSource self) -> bool"""
        return _datamodel.AuxSource_detach(self)

    def clone(self):
        r"""clone(AuxSource self) -> Object"""
        return _datamodel.AuxSource_clone(self)

    def accept(self, visitor):
        r"""accept(AuxSource self, Visitor visitor)"""
        return _datamodel.AuxSource_accept(self, visitor)

# Register AuxSource in _datamodel:
_datamodel.AuxSource_swigregister(AuxSource)

def AuxSource_ClassName():
    r"""AuxSource_ClassName() -> char const *"""
    return _datamodel.AuxSource_ClassName()

def AuxSource_TypeInfo():
    r"""AuxSource_TypeInfo() -> RTTI"""
    return _datamodel.AuxSource_TypeInfo()

def AuxSource_Cast(*args):
    r"""
    AuxSource_Cast(BaseObject o) -> AuxSource
    AuxSource_Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxSource
    """
    return _datamodel.AuxSource_Cast(*args)

def AuxSource_ConstCast(*args):
    r"""
    AuxSource_ConstCast(BaseObject o) -> AuxSource
    AuxSource_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxSource
    """
    return _datamodel.AuxSource_ConstCast(*args)

def AuxSource_Meta():
    r"""AuxSource_Meta() -> MetaObject"""
    return _datamodel.AuxSource_Meta()

class AuxDeviceIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::AuxDeviceIndex 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__(AuxDeviceIndex self) -> AuxDeviceIndex
        __init__(AuxDeviceIndex self, std::string const & name) -> AuxDeviceIndex
        __init__(AuxDeviceIndex self, AuxDeviceIndex arg2) -> AuxDeviceIndex
        """
        _datamodel.AuxDeviceIndex_swiginit(self, _datamodel.new_AuxDeviceIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(AuxDeviceIndex self, AuxDeviceIndex arg2) -> bool"""
        return _datamodel.AuxDeviceIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(AuxDeviceIndex self, AuxDeviceIndex arg2) -> bool"""
        return _datamodel.AuxDeviceIndex___ne__(self, arg2)
    name = property(_datamodel.AuxDeviceIndex_name_get, _datamodel.AuxDeviceIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_AuxDeviceIndex

# Register AuxDeviceIndex in _datamodel:
_datamodel.AuxDeviceIndex_swigregister(AuxDeviceIndex)

class AuxDevice(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::AuxDevice 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 _datamodel.AuxDevice_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.AuxDevice_TypeInfo()

    def className(self):
        r"""className(AuxDevice self) -> char const *"""
        return _datamodel.AuxDevice_className(self)

    def typeInfo(self):
        r"""typeInfo(AuxDevice self) -> RTTI"""
        return _datamodel.AuxDevice_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> AuxDevice
        Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxDevice
        """
        return _datamodel.AuxDevice_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> AuxDevice
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxDevice
        """
        return _datamodel.AuxDevice_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(AuxDevice self, GenericArchive ar)"""
        return _datamodel.AuxDevice_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.AuxDevice_Meta()

    def meta(self):
        r"""meta(AuxDevice self) -> MetaObject"""
        return _datamodel.AuxDevice_meta(self)

    def __init__(self, *args):
        r"""
        __init__(AuxDevice self, AuxDevice other) -> AuxDevice
        __init__(AuxDevice self, std::string const & publicID) -> AuxDevice
        """
        _datamodel.AuxDevice_swiginit(self, _datamodel.new_AuxDevice(*args))
    __swig_destroy__ = _datamodel.delete_AuxDevice

    @staticmethod
    def Create(*args):
        r"""
        Create() -> AuxDevice
        Create(std::string const & publicID) -> AuxDevice
        """
        return _datamodel.AuxDevice_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> AuxDevice"""
        return _datamodel.AuxDevice_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(AuxDevice self, AuxDevice other) -> bool"""
        return _datamodel.AuxDevice___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(AuxDevice self, AuxDevice other) -> bool"""
        return _datamodel.AuxDevice___ne__(self, other)

    def equal(self, other):
        r"""equal(AuxDevice self, AuxDevice other) -> bool"""
        return _datamodel.AuxDevice_equal(self, other)

    def setName(self, name):
        r"""setName(AuxDevice self, std::string const & name)"""
        return _datamodel.AuxDevice_setName(self, name)

    def name(self):
        r"""name(AuxDevice self) -> std::string const &"""
        return _datamodel.AuxDevice_name(self)

    def setDescription(self, description):
        r"""setDescription(AuxDevice self, std::string const & description)"""
        return _datamodel.AuxDevice_setDescription(self, description)

    def description(self):
        r"""description(AuxDevice self) -> std::string const &"""
        return _datamodel.AuxDevice_description(self)

    def setModel(self, model):
        r"""setModel(AuxDevice self, std::string const & model)"""
        return _datamodel.AuxDevice_setModel(self, model)

    def model(self):
        r"""model(AuxDevice self) -> std::string const &"""
        return _datamodel.AuxDevice_model(self)

    def setManufacturer(self, manufacturer):
        r"""setManufacturer(AuxDevice self, std::string const & manufacturer)"""
        return _datamodel.AuxDevice_setManufacturer(self, manufacturer)

    def manufacturer(self):
        r"""manufacturer(AuxDevice self) -> std::string const &"""
        return _datamodel.AuxDevice_manufacturer(self)

    def setRemark(self, remark):
        r"""setRemark(AuxDevice self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.AuxDevice_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(AuxDevice self) -> Blob
        remark(AuxDevice self) -> Blob
        """
        return _datamodel.AuxDevice_remark(self, *args)

    def index(self):
        r"""index(AuxDevice self) -> AuxDeviceIndex"""
        return _datamodel.AuxDevice_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(AuxDevice self, AuxDevice lhs) -> bool"""
        return _datamodel.AuxDevice_equalIndex(self, lhs)

    def add(self, obj):
        r"""add(AuxDevice self, AuxSource obj) -> bool"""
        return _datamodel.AuxDevice_add(self, obj)

    def remove(self, obj):
        r"""remove(AuxDevice self, AuxSource obj) -> bool"""
        return _datamodel.AuxDevice_remove(self, obj)

    def removeAuxSource(self, *args):
        r"""
        removeAuxSource(AuxDevice self, size_t i) -> bool
        removeAuxSource(AuxDevice self, AuxSourceIndex i) -> bool
        """
        return _datamodel.AuxDevice_removeAuxSource(self, *args)

    def auxSourceCount(self):
        r"""auxSourceCount(AuxDevice self) -> size_t"""
        return _datamodel.AuxDevice_auxSourceCount(self)

    def auxSource(self, *args):
        r"""
        auxSource(AuxDevice self, size_t i) -> AuxSource
        auxSource(AuxDevice self, AuxSourceIndex i) -> AuxSource
        """
        return _datamodel.AuxDevice_auxSource(self, *args)

    def inventory(self):
        r"""inventory(AuxDevice self) -> Inventory"""
        return _datamodel.AuxDevice_inventory(self)

    def assign(self, other):
        r"""assign(AuxDevice self, Object other) -> bool"""
        return _datamodel.AuxDevice_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(AuxDevice self, PublicObject parent) -> bool"""
        return _datamodel.AuxDevice_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(AuxDevice self, PublicObject parent) -> bool"""
        return _datamodel.AuxDevice_detachFrom(self, parent)

    def detach(self):
        r"""detach(AuxDevice self) -> bool"""
        return _datamodel.AuxDevice_detach(self)

    def clone(self):
        r"""clone(AuxDevice self) -> Object"""
        return _datamodel.AuxDevice_clone(self)

    def updateChild(self, child):
        r"""updateChild(AuxDevice self, Object child) -> bool"""
        return _datamodel.AuxDevice_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(AuxDevice self, Visitor visitor)"""
        return _datamodel.AuxDevice_accept(self, visitor)

# Register AuxDevice in _datamodel:
_datamodel.AuxDevice_swigregister(AuxDevice)

def AuxDevice_ClassName():
    r"""AuxDevice_ClassName() -> char const *"""
    return _datamodel.AuxDevice_ClassName()

def AuxDevice_TypeInfo():
    r"""AuxDevice_TypeInfo() -> RTTI"""
    return _datamodel.AuxDevice_TypeInfo()

def AuxDevice_Cast(*args):
    r"""
    AuxDevice_Cast(BaseObject o) -> AuxDevice
    AuxDevice_Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxDevice
    """
    return _datamodel.AuxDevice_Cast(*args)

def AuxDevice_ConstCast(*args):
    r"""
    AuxDevice_ConstCast(BaseObject o) -> AuxDevice
    AuxDevice_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxDevice
    """
    return _datamodel.AuxDevice_ConstCast(*args)

def AuxDevice_Meta():
    r"""AuxDevice_Meta() -> MetaObject"""
    return _datamodel.AuxDevice_Meta()

def AuxDevice_Create(*args):
    r"""
    AuxDevice_Create() -> AuxDevice
    AuxDevice_Create(std::string const & publicID) -> AuxDevice
    """
    return _datamodel.AuxDevice_Create(*args)

def AuxDevice_Find(publicID):
    r"""AuxDevice_Find(std::string const & publicID) -> AuxDevice"""
    return _datamodel.AuxDevice_Find(publicID)

class SensorCalibrationIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::SensorCalibrationIndex 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__(SensorCalibrationIndex self) -> SensorCalibrationIndex
        __init__(SensorCalibrationIndex self, std::string const & serialNumber, int channel, Time start) -> SensorCalibrationIndex
        __init__(SensorCalibrationIndex self, SensorCalibrationIndex arg2) -> SensorCalibrationIndex
        """
        _datamodel.SensorCalibrationIndex_swiginit(self, _datamodel.new_SensorCalibrationIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(SensorCalibrationIndex self, SensorCalibrationIndex arg2) -> bool"""
        return _datamodel.SensorCalibrationIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(SensorCalibrationIndex self, SensorCalibrationIndex arg2) -> bool"""
        return _datamodel.SensorCalibrationIndex___ne__(self, arg2)
    serialNumber = property(_datamodel.SensorCalibrationIndex_serialNumber_get, _datamodel.SensorCalibrationIndex_serialNumber_set, doc=r"""serialNumber : std::string""")
    channel = property(_datamodel.SensorCalibrationIndex_channel_get, _datamodel.SensorCalibrationIndex_channel_set, doc=r"""channel : int""")
    start = property(_datamodel.SensorCalibrationIndex_start_get, _datamodel.SensorCalibrationIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_SensorCalibrationIndex

# Register SensorCalibrationIndex in _datamodel:
_datamodel.SensorCalibrationIndex_swigregister(SensorCalibrationIndex)

class SensorCalibration(Object):
    r"""Proxy of C++ Seiscomp::DataModel::SensorCalibration 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 _datamodel.SensorCalibration_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.SensorCalibration_TypeInfo()

    def className(self):
        r"""className(SensorCalibration self) -> char const *"""
        return _datamodel.SensorCalibration_className(self)

    def typeInfo(self):
        r"""typeInfo(SensorCalibration self) -> RTTI"""
        return _datamodel.SensorCalibration_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> SensorCalibration
        Cast(Seiscomp::Core::BaseObjectPtr o) -> SensorCalibration
        """
        return _datamodel.SensorCalibration_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> SensorCalibration
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SensorCalibration
        """
        return _datamodel.SensorCalibration_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(SensorCalibration self, GenericArchive ar)"""
        return _datamodel.SensorCalibration_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.SensorCalibration_Meta()

    def meta(self):
        r"""meta(SensorCalibration self) -> MetaObject"""
        return _datamodel.SensorCalibration_meta(self)

    def __init__(self, *args):
        r"""
        __init__(SensorCalibration self) -> SensorCalibration
        __init__(SensorCalibration self, SensorCalibration other) -> SensorCalibration
        """
        _datamodel.SensorCalibration_swiginit(self, _datamodel.new_SensorCalibration(*args))
    __swig_destroy__ = _datamodel.delete_SensorCalibration

    def __eq__(self, other):
        r"""__eq__(SensorCalibration self, SensorCalibration other) -> bool"""
        return _datamodel.SensorCalibration___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(SensorCalibration self, SensorCalibration other) -> bool"""
        return _datamodel.SensorCalibration___ne__(self, other)

    def equal(self, other):
        r"""equal(SensorCalibration self, SensorCalibration other) -> bool"""
        return _datamodel.SensorCalibration_equal(self, other)

    def setSerialNumber(self, serialNumber):
        r"""setSerialNumber(SensorCalibration self, std::string const & serialNumber)"""
        return _datamodel.SensorCalibration_setSerialNumber(self, serialNumber)

    def serialNumber(self):
        r"""serialNumber(SensorCalibration self) -> std::string const &"""
        return _datamodel.SensorCalibration_serialNumber(self)

    def setChannel(self, channel):
        r"""setChannel(SensorCalibration self, int channel)"""
        return _datamodel.SensorCalibration_setChannel(self, channel)

    def channel(self):
        r"""channel(SensorCalibration self) -> int"""
        return _datamodel.SensorCalibration_channel(self)

    def setStart(self, start):
        r"""setStart(SensorCalibration self, Time start)"""
        return _datamodel.SensorCalibration_setStart(self, start)

    def start(self):
        r"""start(SensorCalibration self) -> Time"""
        return _datamodel.SensorCalibration_start(self)

    def setEnd(self, end):
        r"""setEnd(SensorCalibration self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.SensorCalibration_setEnd(self, end)

    def end(self):
        r"""end(SensorCalibration self) -> Time"""
        return _datamodel.SensorCalibration_end(self)

    def setGain(self, gain):
        r"""setGain(SensorCalibration self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.SensorCalibration_setGain(self, gain)

    def gain(self):
        r"""gain(SensorCalibration self) -> double"""
        return _datamodel.SensorCalibration_gain(self)

    def setGainFrequency(self, gainFrequency):
        r"""setGainFrequency(SensorCalibration self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
        return _datamodel.SensorCalibration_setGainFrequency(self, gainFrequency)

    def gainFrequency(self):
        r"""gainFrequency(SensorCalibration self) -> double"""
        return _datamodel.SensorCalibration_gainFrequency(self)

    def setRemark(self, remark):
        r"""setRemark(SensorCalibration self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.SensorCalibration_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(SensorCalibration self) -> Blob
        remark(SensorCalibration self) -> Blob
        """
        return _datamodel.SensorCalibration_remark(self, *args)

    def index(self):
        r"""index(SensorCalibration self) -> SensorCalibrationIndex"""
        return _datamodel.SensorCalibration_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(SensorCalibration self, SensorCalibration lhs) -> bool"""
        return _datamodel.SensorCalibration_equalIndex(self, lhs)

    def sensor(self):
        r"""sensor(SensorCalibration self) -> Sensor"""
        return _datamodel.SensorCalibration_sensor(self)

    def assign(self, other):
        r"""assign(SensorCalibration self, Object other) -> bool"""
        return _datamodel.SensorCalibration_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(SensorCalibration self, PublicObject parent) -> bool"""
        return _datamodel.SensorCalibration_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(SensorCalibration self, PublicObject parent) -> bool"""
        return _datamodel.SensorCalibration_detachFrom(self, parent)

    def detach(self):
        r"""detach(SensorCalibration self) -> bool"""
        return _datamodel.SensorCalibration_detach(self)

    def clone(self):
        r"""clone(SensorCalibration self) -> Object"""
        return _datamodel.SensorCalibration_clone(self)

    def accept(self, visitor):
        r"""accept(SensorCalibration self, Visitor visitor)"""
        return _datamodel.SensorCalibration_accept(self, visitor)

# Register SensorCalibration in _datamodel:
_datamodel.SensorCalibration_swigregister(SensorCalibration)

def SensorCalibration_ClassName():
    r"""SensorCalibration_ClassName() -> char const *"""
    return _datamodel.SensorCalibration_ClassName()

def SensorCalibration_TypeInfo():
    r"""SensorCalibration_TypeInfo() -> RTTI"""
    return _datamodel.SensorCalibration_TypeInfo()

def SensorCalibration_Cast(*args):
    r"""
    SensorCalibration_Cast(BaseObject o) -> SensorCalibration
    SensorCalibration_Cast(Seiscomp::Core::BaseObjectPtr o) -> SensorCalibration
    """
    return _datamodel.SensorCalibration_Cast(*args)

def SensorCalibration_ConstCast(*args):
    r"""
    SensorCalibration_ConstCast(BaseObject o) -> SensorCalibration
    SensorCalibration_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SensorCalibration
    """
    return _datamodel.SensorCalibration_ConstCast(*args)

def SensorCalibration_Meta():
    r"""SensorCalibration_Meta() -> MetaObject"""
    return _datamodel.SensorCalibration_Meta()

class SensorIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::SensorIndex 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__(SensorIndex self) -> SensorIndex
        __init__(SensorIndex self, std::string const & name) -> SensorIndex
        __init__(SensorIndex self, SensorIndex arg2) -> SensorIndex
        """
        _datamodel.SensorIndex_swiginit(self, _datamodel.new_SensorIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(SensorIndex self, SensorIndex arg2) -> bool"""
        return _datamodel.SensorIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(SensorIndex self, SensorIndex arg2) -> bool"""
        return _datamodel.SensorIndex___ne__(self, arg2)
    name = property(_datamodel.SensorIndex_name_get, _datamodel.SensorIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_SensorIndex

# Register SensorIndex in _datamodel:
_datamodel.SensorIndex_swigregister(SensorIndex)

class Sensor(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Sensor 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 _datamodel.Sensor_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Sensor_TypeInfo()

    def className(self):
        r"""className(Sensor self) -> char const *"""
        return _datamodel.Sensor_className(self)

    def typeInfo(self):
        r"""typeInfo(Sensor self) -> RTTI"""
        return _datamodel.Sensor_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Sensor
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Sensor
        """
        return _datamodel.Sensor_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Sensor
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Sensor
        """
        return _datamodel.Sensor_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Sensor self, GenericArchive ar)"""
        return _datamodel.Sensor_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Sensor_Meta()

    def meta(self):
        r"""meta(Sensor self) -> MetaObject"""
        return _datamodel.Sensor_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Sensor self, Sensor other) -> Sensor
        __init__(Sensor self, std::string const & publicID) -> Sensor
        """
        _datamodel.Sensor_swiginit(self, _datamodel.new_Sensor(*args))
    __swig_destroy__ = _datamodel.delete_Sensor

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Sensor
        Create(std::string const & publicID) -> Sensor
        """
        return _datamodel.Sensor_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Sensor"""
        return _datamodel.Sensor_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Sensor self, Sensor other) -> bool"""
        return _datamodel.Sensor___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Sensor self, Sensor other) -> bool"""
        return _datamodel.Sensor___ne__(self, other)

    def equal(self, other):
        r"""equal(Sensor self, Sensor other) -> bool"""
        return _datamodel.Sensor_equal(self, other)

    def setName(self, name):
        r"""setName(Sensor self, std::string const & name)"""
        return _datamodel.Sensor_setName(self, name)

    def name(self):
        r"""name(Sensor self) -> std::string const &"""
        return _datamodel.Sensor_name(self)

    def setDescription(self, description):
        r"""setDescription(Sensor self, std::string const & description)"""
        return _datamodel.Sensor_setDescription(self, description)

    def description(self):
        r"""description(Sensor self) -> std::string const &"""
        return _datamodel.Sensor_description(self)

    def setModel(self, model):
        r"""setModel(Sensor self, std::string const & model)"""
        return _datamodel.Sensor_setModel(self, model)

    def model(self):
        r"""model(Sensor self) -> std::string const &"""
        return _datamodel.Sensor_model(self)

    def setManufacturer(self, manufacturer):
        r"""setManufacturer(Sensor self, std::string const & manufacturer)"""
        return _datamodel.Sensor_setManufacturer(self, manufacturer)

    def manufacturer(self):
        r"""manufacturer(Sensor self) -> std::string const &"""
        return _datamodel.Sensor_manufacturer(self)

    def setType(self, type):
        r"""setType(Sensor self, std::string const & type)"""
        return _datamodel.Sensor_setType(self, type)

    def type(self):
        r"""type(Sensor self) -> std::string const &"""
        return _datamodel.Sensor_type(self)

    def setUnit(self, unit):
        r"""setUnit(Sensor self, std::string const & unit)"""
        return _datamodel.Sensor_setUnit(self, unit)

    def unit(self):
        r"""unit(Sensor self) -> std::string const &"""
        return _datamodel.Sensor_unit(self)

    def setLowFrequency(self, lowFrequency):
        r"""setLowFrequency(Sensor self, Seiscomp::Core::Optional< double >::Impl const & lowFrequency)"""
        return _datamodel.Sensor_setLowFrequency(self, lowFrequency)

    def lowFrequency(self):
        r"""lowFrequency(Sensor self) -> double"""
        return _datamodel.Sensor_lowFrequency(self)

    def setHighFrequency(self, highFrequency):
        r"""setHighFrequency(Sensor self, Seiscomp::Core::Optional< double >::Impl const & highFrequency)"""
        return _datamodel.Sensor_setHighFrequency(self, highFrequency)

    def highFrequency(self):
        r"""highFrequency(Sensor self) -> double"""
        return _datamodel.Sensor_highFrequency(self)

    def setResponse(self, response):
        r"""setResponse(Sensor self, std::string const & response)"""
        return _datamodel.Sensor_setResponse(self, response)

    def response(self):
        r"""response(Sensor self) -> std::string const &"""
        return _datamodel.Sensor_response(self)

    def setRemark(self, remark):
        r"""setRemark(Sensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.Sensor_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(Sensor self) -> Blob
        remark(Sensor self) -> Blob
        """
        return _datamodel.Sensor_remark(self, *args)

    def index(self):
        r"""index(Sensor self) -> SensorIndex"""
        return _datamodel.Sensor_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Sensor self, Sensor lhs) -> bool"""
        return _datamodel.Sensor_equalIndex(self, lhs)

    def add(self, obj):
        r"""add(Sensor self, SensorCalibration obj) -> bool"""
        return _datamodel.Sensor_add(self, obj)

    def remove(self, obj):
        r"""remove(Sensor self, SensorCalibration obj) -> bool"""
        return _datamodel.Sensor_remove(self, obj)

    def removeSensorCalibration(self, *args):
        r"""
        removeSensorCalibration(Sensor self, size_t i) -> bool
        removeSensorCalibration(Sensor self, SensorCalibrationIndex i) -> bool
        """
        return _datamodel.Sensor_removeSensorCalibration(self, *args)

    def sensorCalibrationCount(self):
        r"""sensorCalibrationCount(Sensor self) -> size_t"""
        return _datamodel.Sensor_sensorCalibrationCount(self)

    def sensorCalibration(self, *args):
        r"""
        sensorCalibration(Sensor self, size_t i) -> SensorCalibration
        sensorCalibration(Sensor self, SensorCalibrationIndex i) -> SensorCalibration
        """
        return _datamodel.Sensor_sensorCalibration(self, *args)

    def inventory(self):
        r"""inventory(Sensor self) -> Inventory"""
        return _datamodel.Sensor_inventory(self)

    def assign(self, other):
        r"""assign(Sensor self, Object other) -> bool"""
        return _datamodel.Sensor_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Sensor self, PublicObject parent) -> bool"""
        return _datamodel.Sensor_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Sensor self, PublicObject parent) -> bool"""
        return _datamodel.Sensor_detachFrom(self, parent)

    def detach(self):
        r"""detach(Sensor self) -> bool"""
        return _datamodel.Sensor_detach(self)

    def clone(self):
        r"""clone(Sensor self) -> Object"""
        return _datamodel.Sensor_clone(self)

    def updateChild(self, child):
        r"""updateChild(Sensor self, Object child) -> bool"""
        return _datamodel.Sensor_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Sensor self, Visitor visitor)"""
        return _datamodel.Sensor_accept(self, visitor)

# Register Sensor in _datamodel:
_datamodel.Sensor_swigregister(Sensor)

def Sensor_ClassName():
    r"""Sensor_ClassName() -> char const *"""
    return _datamodel.Sensor_ClassName()

def Sensor_TypeInfo():
    r"""Sensor_TypeInfo() -> RTTI"""
    return _datamodel.Sensor_TypeInfo()

def Sensor_Cast(*args):
    r"""
    Sensor_Cast(BaseObject o) -> Sensor
    Sensor_Cast(Seiscomp::Core::BaseObjectPtr o) -> Sensor
    """
    return _datamodel.Sensor_Cast(*args)

def Sensor_ConstCast(*args):
    r"""
    Sensor_ConstCast(BaseObject o) -> Sensor
    Sensor_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Sensor
    """
    return _datamodel.Sensor_ConstCast(*args)

def Sensor_Meta():
    r"""Sensor_Meta() -> MetaObject"""
    return _datamodel.Sensor_Meta()

def Sensor_Create(*args):
    r"""
    Sensor_Create() -> Sensor
    Sensor_Create(std::string const & publicID) -> Sensor
    """
    return _datamodel.Sensor_Create(*args)

def Sensor_Find(publicID):
    r"""Sensor_Find(std::string const & publicID) -> Sensor"""
    return _datamodel.Sensor_Find(publicID)

class ResponsePAZIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ResponsePAZIndex 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__(ResponsePAZIndex self) -> ResponsePAZIndex
        __init__(ResponsePAZIndex self, std::string const & name) -> ResponsePAZIndex
        __init__(ResponsePAZIndex self, ResponsePAZIndex arg2) -> ResponsePAZIndex
        """
        _datamodel.ResponsePAZIndex_swiginit(self, _datamodel.new_ResponsePAZIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ResponsePAZIndex self, ResponsePAZIndex arg2) -> bool"""
        return _datamodel.ResponsePAZIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ResponsePAZIndex self, ResponsePAZIndex arg2) -> bool"""
        return _datamodel.ResponsePAZIndex___ne__(self, arg2)
    name = property(_datamodel.ResponsePAZIndex_name_get, _datamodel.ResponsePAZIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_ResponsePAZIndex

# Register ResponsePAZIndex in _datamodel:
_datamodel.ResponsePAZIndex_swigregister(ResponsePAZIndex)

class ResponsePAZ(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ResponsePAZ 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 _datamodel.ResponsePAZ_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ResponsePAZ_TypeInfo()

    def className(self):
        r"""className(ResponsePAZ self) -> char const *"""
        return _datamodel.ResponsePAZ_className(self)

    def typeInfo(self):
        r"""typeInfo(ResponsePAZ self) -> RTTI"""
        return _datamodel.ResponsePAZ_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ResponsePAZ
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponsePAZ
        """
        return _datamodel.ResponsePAZ_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ResponsePAZ
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponsePAZ
        """
        return _datamodel.ResponsePAZ_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ResponsePAZ self, GenericArchive ar)"""
        return _datamodel.ResponsePAZ_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ResponsePAZ_Meta()

    def meta(self):
        r"""meta(ResponsePAZ self) -> MetaObject"""
        return _datamodel.ResponsePAZ_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ResponsePAZ self, ResponsePAZ other) -> ResponsePAZ
        __init__(ResponsePAZ self, std::string const & publicID) -> ResponsePAZ
        """
        _datamodel.ResponsePAZ_swiginit(self, _datamodel.new_ResponsePAZ(*args))
    __swig_destroy__ = _datamodel.delete_ResponsePAZ

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ResponsePAZ
        Create(std::string const & publicID) -> ResponsePAZ
        """
        return _datamodel.ResponsePAZ_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ResponsePAZ"""
        return _datamodel.ResponsePAZ_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ResponsePAZ self, ResponsePAZ other) -> bool"""
        return _datamodel.ResponsePAZ___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ResponsePAZ self, ResponsePAZ other) -> bool"""
        return _datamodel.ResponsePAZ___ne__(self, other)

    def equal(self, other):
        r"""equal(ResponsePAZ self, ResponsePAZ other) -> bool"""
        return _datamodel.ResponsePAZ_equal(self, other)

    def setName(self, name):
        r"""setName(ResponsePAZ self, std::string const & name)"""
        return _datamodel.ResponsePAZ_setName(self, name)

    def name(self):
        r"""name(ResponsePAZ self) -> std::string const &"""
        return _datamodel.ResponsePAZ_name(self)

    def setType(self, type):
        r"""setType(ResponsePAZ self, std::string const & type)"""
        return _datamodel.ResponsePAZ_setType(self, type)

    def type(self):
        r"""type(ResponsePAZ self) -> std::string const &"""
        return _datamodel.ResponsePAZ_type(self)

    def setGain(self, gain):
        r"""setGain(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.ResponsePAZ_setGain(self, gain)

    def gain(self):
        r"""gain(ResponsePAZ self) -> double"""
        return _datamodel.ResponsePAZ_gain(self)

    def setGainFrequency(self, gainFrequency):
        r"""setGainFrequency(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
        return _datamodel.ResponsePAZ_setGainFrequency(self, gainFrequency)

    def gainFrequency(self):
        r"""gainFrequency(ResponsePAZ self) -> double"""
        return _datamodel.ResponsePAZ_gainFrequency(self)

    def setNormalizationFactor(self, normalizationFactor):
        r"""setNormalizationFactor(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & normalizationFactor)"""
        return _datamodel.ResponsePAZ_setNormalizationFactor(self, normalizationFactor)

    def normalizationFactor(self):
        r"""normalizationFactor(ResponsePAZ self) -> double"""
        return _datamodel.ResponsePAZ_normalizationFactor(self)

    def setNormalizationFrequency(self, normalizationFrequency):
        r"""setNormalizationFrequency(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & normalizationFrequency)"""
        return _datamodel.ResponsePAZ_setNormalizationFrequency(self, normalizationFrequency)

    def normalizationFrequency(self):
        r"""normalizationFrequency(ResponsePAZ self) -> double"""
        return _datamodel.ResponsePAZ_normalizationFrequency(self)

    def setNumberOfZeros(self, numberOfZeros):
        r"""setNumberOfZeros(ResponsePAZ self, Seiscomp::Core::Optional< int >::Impl const & numberOfZeros)"""
        return _datamodel.ResponsePAZ_setNumberOfZeros(self, numberOfZeros)

    def numberOfZeros(self):
        r"""numberOfZeros(ResponsePAZ self) -> int"""
        return _datamodel.ResponsePAZ_numberOfZeros(self)

    def setNumberOfPoles(self, numberOfPoles):
        r"""setNumberOfPoles(ResponsePAZ self, Seiscomp::Core::Optional< int >::Impl const & numberOfPoles)"""
        return _datamodel.ResponsePAZ_setNumberOfPoles(self, numberOfPoles)

    def numberOfPoles(self):
        r"""numberOfPoles(ResponsePAZ self) -> int"""
        return _datamodel.ResponsePAZ_numberOfPoles(self)

    def setZeros(self, zeros):
        r"""setZeros(ResponsePAZ self, Seiscomp::Core::Optional< Seiscomp::DataModel::ComplexArray >::Impl const & zeros)"""
        return _datamodel.ResponsePAZ_setZeros(self, zeros)

    def zeros(self, *args):
        r"""
        zeros(ResponsePAZ self) -> ComplexArray
        zeros(ResponsePAZ self) -> ComplexArray
        """
        return _datamodel.ResponsePAZ_zeros(self, *args)

    def setPoles(self, poles):
        r"""setPoles(ResponsePAZ self, Seiscomp::Core::Optional< Seiscomp::DataModel::ComplexArray >::Impl const & poles)"""
        return _datamodel.ResponsePAZ_setPoles(self, poles)

    def poles(self, *args):
        r"""
        poles(ResponsePAZ self) -> ComplexArray
        poles(ResponsePAZ self) -> ComplexArray
        """
        return _datamodel.ResponsePAZ_poles(self, *args)

    def setRemark(self, remark):
        r"""setRemark(ResponsePAZ self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.ResponsePAZ_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(ResponsePAZ self) -> Blob
        remark(ResponsePAZ self) -> Blob
        """
        return _datamodel.ResponsePAZ_remark(self, *args)

    def setDecimationFactor(self, decimationFactor):
        r"""setDecimationFactor(ResponsePAZ self, Seiscomp::Core::Optional< int >::Impl const & decimationFactor)"""
        return _datamodel.ResponsePAZ_setDecimationFactor(self, decimationFactor)

    def decimationFactor(self):
        r"""decimationFactor(ResponsePAZ self) -> int"""
        return _datamodel.ResponsePAZ_decimationFactor(self)

    def setDelay(self, delay):
        r"""setDelay(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & delay)"""
        return _datamodel.ResponsePAZ_setDelay(self, delay)

    def delay(self):
        r"""delay(ResponsePAZ self) -> double"""
        return _datamodel.ResponsePAZ_delay(self)

    def setCorrection(self, correction):
        r"""setCorrection(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & correction)"""
        return _datamodel.ResponsePAZ_setCorrection(self, correction)

    def correction(self):
        r"""correction(ResponsePAZ self) -> double"""
        return _datamodel.ResponsePAZ_correction(self)

    def index(self):
        r"""index(ResponsePAZ self) -> ResponsePAZIndex"""
        return _datamodel.ResponsePAZ_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ResponsePAZ self, ResponsePAZ lhs) -> bool"""
        return _datamodel.ResponsePAZ_equalIndex(self, lhs)

    def inventory(self):
        r"""inventory(ResponsePAZ self) -> Inventory"""
        return _datamodel.ResponsePAZ_inventory(self)

    def assign(self, other):
        r"""assign(ResponsePAZ self, Object other) -> bool"""
        return _datamodel.ResponsePAZ_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ResponsePAZ self, PublicObject parent) -> bool"""
        return _datamodel.ResponsePAZ_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ResponsePAZ self, PublicObject parent) -> bool"""
        return _datamodel.ResponsePAZ_detachFrom(self, parent)

    def detach(self):
        r"""detach(ResponsePAZ self) -> bool"""
        return _datamodel.ResponsePAZ_detach(self)

    def clone(self):
        r"""clone(ResponsePAZ self) -> Object"""
        return _datamodel.ResponsePAZ_clone(self)

    def updateChild(self, child):
        r"""updateChild(ResponsePAZ self, Object child) -> bool"""
        return _datamodel.ResponsePAZ_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ResponsePAZ self, Visitor visitor)"""
        return _datamodel.ResponsePAZ_accept(self, visitor)

# Register ResponsePAZ in _datamodel:
_datamodel.ResponsePAZ_swigregister(ResponsePAZ)

def ResponsePAZ_ClassName():
    r"""ResponsePAZ_ClassName() -> char const *"""
    return _datamodel.ResponsePAZ_ClassName()

def ResponsePAZ_TypeInfo():
    r"""ResponsePAZ_TypeInfo() -> RTTI"""
    return _datamodel.ResponsePAZ_TypeInfo()

def ResponsePAZ_Cast(*args):
    r"""
    ResponsePAZ_Cast(BaseObject o) -> ResponsePAZ
    ResponsePAZ_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponsePAZ
    """
    return _datamodel.ResponsePAZ_Cast(*args)

def ResponsePAZ_ConstCast(*args):
    r"""
    ResponsePAZ_ConstCast(BaseObject o) -> ResponsePAZ
    ResponsePAZ_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponsePAZ
    """
    return _datamodel.ResponsePAZ_ConstCast(*args)

def ResponsePAZ_Meta():
    r"""ResponsePAZ_Meta() -> MetaObject"""
    return _datamodel.ResponsePAZ_Meta()

def ResponsePAZ_Create(*args):
    r"""
    ResponsePAZ_Create() -> ResponsePAZ
    ResponsePAZ_Create(std::string const & publicID) -> ResponsePAZ
    """
    return _datamodel.ResponsePAZ_Create(*args)

def ResponsePAZ_Find(publicID):
    r"""ResponsePAZ_Find(std::string const & publicID) -> ResponsePAZ"""
    return _datamodel.ResponsePAZ_Find(publicID)

class ResponsePolynomialIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ResponsePolynomialIndex 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__(ResponsePolynomialIndex self) -> ResponsePolynomialIndex
        __init__(ResponsePolynomialIndex self, std::string const & name) -> ResponsePolynomialIndex
        __init__(ResponsePolynomialIndex self, ResponsePolynomialIndex arg2) -> ResponsePolynomialIndex
        """
        _datamodel.ResponsePolynomialIndex_swiginit(self, _datamodel.new_ResponsePolynomialIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ResponsePolynomialIndex self, ResponsePolynomialIndex arg2) -> bool"""
        return _datamodel.ResponsePolynomialIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ResponsePolynomialIndex self, ResponsePolynomialIndex arg2) -> bool"""
        return _datamodel.ResponsePolynomialIndex___ne__(self, arg2)
    name = property(_datamodel.ResponsePolynomialIndex_name_get, _datamodel.ResponsePolynomialIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_ResponsePolynomialIndex

# Register ResponsePolynomialIndex in _datamodel:
_datamodel.ResponsePolynomialIndex_swigregister(ResponsePolynomialIndex)

class ResponsePolynomial(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ResponsePolynomial 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 _datamodel.ResponsePolynomial_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ResponsePolynomial_TypeInfo()

    def className(self):
        r"""className(ResponsePolynomial self) -> char const *"""
        return _datamodel.ResponsePolynomial_className(self)

    def typeInfo(self):
        r"""typeInfo(ResponsePolynomial self) -> RTTI"""
        return _datamodel.ResponsePolynomial_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ResponsePolynomial
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponsePolynomial
        """
        return _datamodel.ResponsePolynomial_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ResponsePolynomial
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponsePolynomial
        """
        return _datamodel.ResponsePolynomial_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ResponsePolynomial self, GenericArchive ar)"""
        return _datamodel.ResponsePolynomial_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ResponsePolynomial_Meta()

    def meta(self):
        r"""meta(ResponsePolynomial self) -> MetaObject"""
        return _datamodel.ResponsePolynomial_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ResponsePolynomial self, ResponsePolynomial other) -> ResponsePolynomial
        __init__(ResponsePolynomial self, std::string const & publicID) -> ResponsePolynomial
        """
        _datamodel.ResponsePolynomial_swiginit(self, _datamodel.new_ResponsePolynomial(*args))
    __swig_destroy__ = _datamodel.delete_ResponsePolynomial

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ResponsePolynomial
        Create(std::string const & publicID) -> ResponsePolynomial
        """
        return _datamodel.ResponsePolynomial_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ResponsePolynomial"""
        return _datamodel.ResponsePolynomial_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ResponsePolynomial self, ResponsePolynomial other) -> bool"""
        return _datamodel.ResponsePolynomial___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ResponsePolynomial self, ResponsePolynomial other) -> bool"""
        return _datamodel.ResponsePolynomial___ne__(self, other)

    def equal(self, other):
        r"""equal(ResponsePolynomial self, ResponsePolynomial other) -> bool"""
        return _datamodel.ResponsePolynomial_equal(self, other)

    def setName(self, name):
        r"""setName(ResponsePolynomial self, std::string const & name)"""
        return _datamodel.ResponsePolynomial_setName(self, name)

    def name(self):
        r"""name(ResponsePolynomial self) -> std::string const &"""
        return _datamodel.ResponsePolynomial_name(self)

    def setGain(self, gain):
        r"""setGain(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.ResponsePolynomial_setGain(self, gain)

    def gain(self):
        r"""gain(ResponsePolynomial self) -> double"""
        return _datamodel.ResponsePolynomial_gain(self)

    def setGainFrequency(self, gainFrequency):
        r"""setGainFrequency(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
        return _datamodel.ResponsePolynomial_setGainFrequency(self, gainFrequency)

    def gainFrequency(self):
        r"""gainFrequency(ResponsePolynomial self) -> double"""
        return _datamodel.ResponsePolynomial_gainFrequency(self)

    def setFrequencyUnit(self, frequencyUnit):
        r"""setFrequencyUnit(ResponsePolynomial self, std::string const & frequencyUnit)"""
        return _datamodel.ResponsePolynomial_setFrequencyUnit(self, frequencyUnit)

    def frequencyUnit(self):
        r"""frequencyUnit(ResponsePolynomial self) -> std::string const &"""
        return _datamodel.ResponsePolynomial_frequencyUnit(self)

    def setApproximationType(self, approximationType):
        r"""setApproximationType(ResponsePolynomial self, std::string const & approximationType)"""
        return _datamodel.ResponsePolynomial_setApproximationType(self, approximationType)

    def approximationType(self):
        r"""approximationType(ResponsePolynomial self) -> std::string const &"""
        return _datamodel.ResponsePolynomial_approximationType(self)

    def setApproximationLowerBound(self, approximationLowerBound):
        r"""setApproximationLowerBound(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & approximationLowerBound)"""
        return _datamodel.ResponsePolynomial_setApproximationLowerBound(self, approximationLowerBound)

    def approximationLowerBound(self):
        r"""approximationLowerBound(ResponsePolynomial self) -> double"""
        return _datamodel.ResponsePolynomial_approximationLowerBound(self)

    def setApproximationUpperBound(self, approximationUpperBound):
        r"""setApproximationUpperBound(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & approximationUpperBound)"""
        return _datamodel.ResponsePolynomial_setApproximationUpperBound(self, approximationUpperBound)

    def approximationUpperBound(self):
        r"""approximationUpperBound(ResponsePolynomial self) -> double"""
        return _datamodel.ResponsePolynomial_approximationUpperBound(self)

    def setApproximationError(self, approximationError):
        r"""setApproximationError(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & approximationError)"""
        return _datamodel.ResponsePolynomial_setApproximationError(self, approximationError)

    def approximationError(self):
        r"""approximationError(ResponsePolynomial self) -> double"""
        return _datamodel.ResponsePolynomial_approximationError(self)

    def setNumberOfCoefficients(self, numberOfCoefficients):
        r"""setNumberOfCoefficients(ResponsePolynomial self, Seiscomp::Core::Optional< int >::Impl const & numberOfCoefficients)"""
        return _datamodel.ResponsePolynomial_setNumberOfCoefficients(self, numberOfCoefficients)

    def numberOfCoefficients(self):
        r"""numberOfCoefficients(ResponsePolynomial self) -> int"""
        return _datamodel.ResponsePolynomial_numberOfCoefficients(self)

    def setCoefficients(self, coefficients):
        r"""setCoefficients(ResponsePolynomial self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & coefficients)"""
        return _datamodel.ResponsePolynomial_setCoefficients(self, coefficients)

    def coefficients(self, *args):
        r"""
        coefficients(ResponsePolynomial self) -> RealArray
        coefficients(ResponsePolynomial self) -> RealArray
        """
        return _datamodel.ResponsePolynomial_coefficients(self, *args)

    def setRemark(self, remark):
        r"""setRemark(ResponsePolynomial self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.ResponsePolynomial_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(ResponsePolynomial self) -> Blob
        remark(ResponsePolynomial self) -> Blob
        """
        return _datamodel.ResponsePolynomial_remark(self, *args)

    def index(self):
        r"""index(ResponsePolynomial self) -> ResponsePolynomialIndex"""
        return _datamodel.ResponsePolynomial_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ResponsePolynomial self, ResponsePolynomial lhs) -> bool"""
        return _datamodel.ResponsePolynomial_equalIndex(self, lhs)

    def inventory(self):
        r"""inventory(ResponsePolynomial self) -> Inventory"""
        return _datamodel.ResponsePolynomial_inventory(self)

    def assign(self, other):
        r"""assign(ResponsePolynomial self, Object other) -> bool"""
        return _datamodel.ResponsePolynomial_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ResponsePolynomial self, PublicObject parent) -> bool"""
        return _datamodel.ResponsePolynomial_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ResponsePolynomial self, PublicObject parent) -> bool"""
        return _datamodel.ResponsePolynomial_detachFrom(self, parent)

    def detach(self):
        r"""detach(ResponsePolynomial self) -> bool"""
        return _datamodel.ResponsePolynomial_detach(self)

    def clone(self):
        r"""clone(ResponsePolynomial self) -> Object"""
        return _datamodel.ResponsePolynomial_clone(self)

    def updateChild(self, child):
        r"""updateChild(ResponsePolynomial self, Object child) -> bool"""
        return _datamodel.ResponsePolynomial_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ResponsePolynomial self, Visitor visitor)"""
        return _datamodel.ResponsePolynomial_accept(self, visitor)

# Register ResponsePolynomial in _datamodel:
_datamodel.ResponsePolynomial_swigregister(ResponsePolynomial)

def ResponsePolynomial_ClassName():
    r"""ResponsePolynomial_ClassName() -> char const *"""
    return _datamodel.ResponsePolynomial_ClassName()

def ResponsePolynomial_TypeInfo():
    r"""ResponsePolynomial_TypeInfo() -> RTTI"""
    return _datamodel.ResponsePolynomial_TypeInfo()

def ResponsePolynomial_Cast(*args):
    r"""
    ResponsePolynomial_Cast(BaseObject o) -> ResponsePolynomial
    ResponsePolynomial_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponsePolynomial
    """
    return _datamodel.ResponsePolynomial_Cast(*args)

def ResponsePolynomial_ConstCast(*args):
    r"""
    ResponsePolynomial_ConstCast(BaseObject o) -> ResponsePolynomial
    ResponsePolynomial_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponsePolynomial
    """
    return _datamodel.ResponsePolynomial_ConstCast(*args)

def ResponsePolynomial_Meta():
    r"""ResponsePolynomial_Meta() -> MetaObject"""
    return _datamodel.ResponsePolynomial_Meta()

def ResponsePolynomial_Create(*args):
    r"""
    ResponsePolynomial_Create() -> ResponsePolynomial
    ResponsePolynomial_Create(std::string const & publicID) -> ResponsePolynomial
    """
    return _datamodel.ResponsePolynomial_Create(*args)

def ResponsePolynomial_Find(publicID):
    r"""ResponsePolynomial_Find(std::string const & publicID) -> ResponsePolynomial"""
    return _datamodel.ResponsePolynomial_Find(publicID)

class ResponseFAPIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ResponseFAPIndex 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__(ResponseFAPIndex self) -> ResponseFAPIndex
        __init__(ResponseFAPIndex self, std::string const & name) -> ResponseFAPIndex
        __init__(ResponseFAPIndex self, ResponseFAPIndex arg2) -> ResponseFAPIndex
        """
        _datamodel.ResponseFAPIndex_swiginit(self, _datamodel.new_ResponseFAPIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ResponseFAPIndex self, ResponseFAPIndex arg2) -> bool"""
        return _datamodel.ResponseFAPIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ResponseFAPIndex self, ResponseFAPIndex arg2) -> bool"""
        return _datamodel.ResponseFAPIndex___ne__(self, arg2)
    name = property(_datamodel.ResponseFAPIndex_name_get, _datamodel.ResponseFAPIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_ResponseFAPIndex

# Register ResponseFAPIndex in _datamodel:
_datamodel.ResponseFAPIndex_swigregister(ResponseFAPIndex)

class ResponseFAP(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ResponseFAP 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 _datamodel.ResponseFAP_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ResponseFAP_TypeInfo()

    def className(self):
        r"""className(ResponseFAP self) -> char const *"""
        return _datamodel.ResponseFAP_className(self)

    def typeInfo(self):
        r"""typeInfo(ResponseFAP self) -> RTTI"""
        return _datamodel.ResponseFAP_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ResponseFAP
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseFAP
        """
        return _datamodel.ResponseFAP_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ResponseFAP
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseFAP
        """
        return _datamodel.ResponseFAP_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ResponseFAP self, GenericArchive ar)"""
        return _datamodel.ResponseFAP_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ResponseFAP_Meta()

    def meta(self):
        r"""meta(ResponseFAP self) -> MetaObject"""
        return _datamodel.ResponseFAP_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ResponseFAP self, ResponseFAP other) -> ResponseFAP
        __init__(ResponseFAP self, std::string const & publicID) -> ResponseFAP
        """
        _datamodel.ResponseFAP_swiginit(self, _datamodel.new_ResponseFAP(*args))
    __swig_destroy__ = _datamodel.delete_ResponseFAP

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ResponseFAP
        Create(std::string const & publicID) -> ResponseFAP
        """
        return _datamodel.ResponseFAP_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ResponseFAP"""
        return _datamodel.ResponseFAP_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ResponseFAP self, ResponseFAP other) -> bool"""
        return _datamodel.ResponseFAP___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ResponseFAP self, ResponseFAP other) -> bool"""
        return _datamodel.ResponseFAP___ne__(self, other)

    def equal(self, other):
        r"""equal(ResponseFAP self, ResponseFAP other) -> bool"""
        return _datamodel.ResponseFAP_equal(self, other)

    def setName(self, name):
        r"""setName(ResponseFAP self, std::string const & name)"""
        return _datamodel.ResponseFAP_setName(self, name)

    def name(self):
        r"""name(ResponseFAP self) -> std::string const &"""
        return _datamodel.ResponseFAP_name(self)

    def setGain(self, gain):
        r"""setGain(ResponseFAP self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.ResponseFAP_setGain(self, gain)

    def gain(self):
        r"""gain(ResponseFAP self) -> double"""
        return _datamodel.ResponseFAP_gain(self)

    def setGainFrequency(self, gainFrequency):
        r"""setGainFrequency(ResponseFAP self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
        return _datamodel.ResponseFAP_setGainFrequency(self, gainFrequency)

    def gainFrequency(self):
        r"""gainFrequency(ResponseFAP self) -> double"""
        return _datamodel.ResponseFAP_gainFrequency(self)

    def setNumberOfTuples(self, numberOfTuples):
        r"""setNumberOfTuples(ResponseFAP self, Seiscomp::Core::Optional< int >::Impl const & numberOfTuples)"""
        return _datamodel.ResponseFAP_setNumberOfTuples(self, numberOfTuples)

    def numberOfTuples(self):
        r"""numberOfTuples(ResponseFAP self) -> int"""
        return _datamodel.ResponseFAP_numberOfTuples(self)

    def setTuples(self, tuples):
        r"""setTuples(ResponseFAP self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & tuples)"""
        return _datamodel.ResponseFAP_setTuples(self, tuples)

    def tuples(self, *args):
        r"""
        tuples(ResponseFAP self) -> RealArray
        tuples(ResponseFAP self) -> RealArray
        """
        return _datamodel.ResponseFAP_tuples(self, *args)

    def setRemark(self, remark):
        r"""setRemark(ResponseFAP self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.ResponseFAP_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(ResponseFAP self) -> Blob
        remark(ResponseFAP self) -> Blob
        """
        return _datamodel.ResponseFAP_remark(self, *args)

    def index(self):
        r"""index(ResponseFAP self) -> ResponseFAPIndex"""
        return _datamodel.ResponseFAP_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ResponseFAP self, ResponseFAP lhs) -> bool"""
        return _datamodel.ResponseFAP_equalIndex(self, lhs)

    def inventory(self):
        r"""inventory(ResponseFAP self) -> Inventory"""
        return _datamodel.ResponseFAP_inventory(self)

    def assign(self, other):
        r"""assign(ResponseFAP self, Object other) -> bool"""
        return _datamodel.ResponseFAP_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ResponseFAP self, PublicObject parent) -> bool"""
        return _datamodel.ResponseFAP_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ResponseFAP self, PublicObject parent) -> bool"""
        return _datamodel.ResponseFAP_detachFrom(self, parent)

    def detach(self):
        r"""detach(ResponseFAP self) -> bool"""
        return _datamodel.ResponseFAP_detach(self)

    def clone(self):
        r"""clone(ResponseFAP self) -> Object"""
        return _datamodel.ResponseFAP_clone(self)

    def updateChild(self, child):
        r"""updateChild(ResponseFAP self, Object child) -> bool"""
        return _datamodel.ResponseFAP_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ResponseFAP self, Visitor visitor)"""
        return _datamodel.ResponseFAP_accept(self, visitor)

# Register ResponseFAP in _datamodel:
_datamodel.ResponseFAP_swigregister(ResponseFAP)

def ResponseFAP_ClassName():
    r"""ResponseFAP_ClassName() -> char const *"""
    return _datamodel.ResponseFAP_ClassName()

def ResponseFAP_TypeInfo():
    r"""ResponseFAP_TypeInfo() -> RTTI"""
    return _datamodel.ResponseFAP_TypeInfo()

def ResponseFAP_Cast(*args):
    r"""
    ResponseFAP_Cast(BaseObject o) -> ResponseFAP
    ResponseFAP_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseFAP
    """
    return _datamodel.ResponseFAP_Cast(*args)

def ResponseFAP_ConstCast(*args):
    r"""
    ResponseFAP_ConstCast(BaseObject o) -> ResponseFAP
    ResponseFAP_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseFAP
    """
    return _datamodel.ResponseFAP_ConstCast(*args)

def ResponseFAP_Meta():
    r"""ResponseFAP_Meta() -> MetaObject"""
    return _datamodel.ResponseFAP_Meta()

def ResponseFAP_Create(*args):
    r"""
    ResponseFAP_Create() -> ResponseFAP
    ResponseFAP_Create(std::string const & publicID) -> ResponseFAP
    """
    return _datamodel.ResponseFAP_Create(*args)

def ResponseFAP_Find(publicID):
    r"""ResponseFAP_Find(std::string const & publicID) -> ResponseFAP"""
    return _datamodel.ResponseFAP_Find(publicID)

class ResponseFIRIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ResponseFIRIndex 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__(ResponseFIRIndex self) -> ResponseFIRIndex
        __init__(ResponseFIRIndex self, std::string const & name) -> ResponseFIRIndex
        __init__(ResponseFIRIndex self, ResponseFIRIndex arg2) -> ResponseFIRIndex
        """
        _datamodel.ResponseFIRIndex_swiginit(self, _datamodel.new_ResponseFIRIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ResponseFIRIndex self, ResponseFIRIndex arg2) -> bool"""
        return _datamodel.ResponseFIRIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ResponseFIRIndex self, ResponseFIRIndex arg2) -> bool"""
        return _datamodel.ResponseFIRIndex___ne__(self, arg2)
    name = property(_datamodel.ResponseFIRIndex_name_get, _datamodel.ResponseFIRIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_ResponseFIRIndex

# Register ResponseFIRIndex in _datamodel:
_datamodel.ResponseFIRIndex_swigregister(ResponseFIRIndex)

class ResponseFIR(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ResponseFIR 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 _datamodel.ResponseFIR_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ResponseFIR_TypeInfo()

    def className(self):
        r"""className(ResponseFIR self) -> char const *"""
        return _datamodel.ResponseFIR_className(self)

    def typeInfo(self):
        r"""typeInfo(ResponseFIR self) -> RTTI"""
        return _datamodel.ResponseFIR_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ResponseFIR
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseFIR
        """
        return _datamodel.ResponseFIR_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ResponseFIR
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseFIR
        """
        return _datamodel.ResponseFIR_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ResponseFIR self, GenericArchive ar)"""
        return _datamodel.ResponseFIR_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ResponseFIR_Meta()

    def meta(self):
        r"""meta(ResponseFIR self) -> MetaObject"""
        return _datamodel.ResponseFIR_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ResponseFIR self, ResponseFIR other) -> ResponseFIR
        __init__(ResponseFIR self, std::string const & publicID) -> ResponseFIR
        """
        _datamodel.ResponseFIR_swiginit(self, _datamodel.new_ResponseFIR(*args))
    __swig_destroy__ = _datamodel.delete_ResponseFIR

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ResponseFIR
        Create(std::string const & publicID) -> ResponseFIR
        """
        return _datamodel.ResponseFIR_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ResponseFIR"""
        return _datamodel.ResponseFIR_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ResponseFIR self, ResponseFIR other) -> bool"""
        return _datamodel.ResponseFIR___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ResponseFIR self, ResponseFIR other) -> bool"""
        return _datamodel.ResponseFIR___ne__(self, other)

    def equal(self, other):
        r"""equal(ResponseFIR self, ResponseFIR other) -> bool"""
        return _datamodel.ResponseFIR_equal(self, other)

    def setName(self, name):
        r"""setName(ResponseFIR self, std::string const & name)"""
        return _datamodel.ResponseFIR_setName(self, name)

    def name(self):
        r"""name(ResponseFIR self) -> std::string const &"""
        return _datamodel.ResponseFIR_name(self)

    def setGain(self, gain):
        r"""setGain(ResponseFIR self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.ResponseFIR_setGain(self, gain)

    def gain(self):
        r"""gain(ResponseFIR self) -> double"""
        return _datamodel.ResponseFIR_gain(self)

    def setGainFrequency(self, gainFrequency):
        r"""setGainFrequency(ResponseFIR self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
        return _datamodel.ResponseFIR_setGainFrequency(self, gainFrequency)

    def gainFrequency(self):
        r"""gainFrequency(ResponseFIR self) -> double"""
        return _datamodel.ResponseFIR_gainFrequency(self)

    def setDecimationFactor(self, decimationFactor):
        r"""setDecimationFactor(ResponseFIR self, Seiscomp::Core::Optional< int >::Impl const & decimationFactor)"""
        return _datamodel.ResponseFIR_setDecimationFactor(self, decimationFactor)

    def decimationFactor(self):
        r"""decimationFactor(ResponseFIR self) -> int"""
        return _datamodel.ResponseFIR_decimationFactor(self)

    def setDelay(self, delay):
        r"""setDelay(ResponseFIR self, Seiscomp::Core::Optional< double >::Impl const & delay)"""
        return _datamodel.ResponseFIR_setDelay(self, delay)

    def delay(self):
        r"""delay(ResponseFIR self) -> double"""
        return _datamodel.ResponseFIR_delay(self)

    def setCorrection(self, correction):
        r"""setCorrection(ResponseFIR self, Seiscomp::Core::Optional< double >::Impl const & correction)"""
        return _datamodel.ResponseFIR_setCorrection(self, correction)

    def correction(self):
        r"""correction(ResponseFIR self) -> double"""
        return _datamodel.ResponseFIR_correction(self)

    def setNumberOfCoefficients(self, numberOfCoefficients):
        r"""setNumberOfCoefficients(ResponseFIR self, Seiscomp::Core::Optional< int >::Impl const & numberOfCoefficients)"""
        return _datamodel.ResponseFIR_setNumberOfCoefficients(self, numberOfCoefficients)

    def numberOfCoefficients(self):
        r"""numberOfCoefficients(ResponseFIR self) -> int"""
        return _datamodel.ResponseFIR_numberOfCoefficients(self)

    def setSymmetry(self, symmetry):
        r"""setSymmetry(ResponseFIR self, std::string const & symmetry)"""
        return _datamodel.ResponseFIR_setSymmetry(self, symmetry)

    def symmetry(self):
        r"""symmetry(ResponseFIR self) -> std::string const &"""
        return _datamodel.ResponseFIR_symmetry(self)

    def setCoefficients(self, coefficients):
        r"""setCoefficients(ResponseFIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & coefficients)"""
        return _datamodel.ResponseFIR_setCoefficients(self, coefficients)

    def coefficients(self, *args):
        r"""
        coefficients(ResponseFIR self) -> RealArray
        coefficients(ResponseFIR self) -> RealArray
        """
        return _datamodel.ResponseFIR_coefficients(self, *args)

    def setRemark(self, remark):
        r"""setRemark(ResponseFIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.ResponseFIR_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(ResponseFIR self) -> Blob
        remark(ResponseFIR self) -> Blob
        """
        return _datamodel.ResponseFIR_remark(self, *args)

    def index(self):
        r"""index(ResponseFIR self) -> ResponseFIRIndex"""
        return _datamodel.ResponseFIR_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ResponseFIR self, ResponseFIR lhs) -> bool"""
        return _datamodel.ResponseFIR_equalIndex(self, lhs)

    def inventory(self):
        r"""inventory(ResponseFIR self) -> Inventory"""
        return _datamodel.ResponseFIR_inventory(self)

    def assign(self, other):
        r"""assign(ResponseFIR self, Object other) -> bool"""
        return _datamodel.ResponseFIR_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ResponseFIR self, PublicObject parent) -> bool"""
        return _datamodel.ResponseFIR_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ResponseFIR self, PublicObject parent) -> bool"""
        return _datamodel.ResponseFIR_detachFrom(self, parent)

    def detach(self):
        r"""detach(ResponseFIR self) -> bool"""
        return _datamodel.ResponseFIR_detach(self)

    def clone(self):
        r"""clone(ResponseFIR self) -> Object"""
        return _datamodel.ResponseFIR_clone(self)

    def updateChild(self, child):
        r"""updateChild(ResponseFIR self, Object child) -> bool"""
        return _datamodel.ResponseFIR_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ResponseFIR self, Visitor visitor)"""
        return _datamodel.ResponseFIR_accept(self, visitor)

# Register ResponseFIR in _datamodel:
_datamodel.ResponseFIR_swigregister(ResponseFIR)

def ResponseFIR_ClassName():
    r"""ResponseFIR_ClassName() -> char const *"""
    return _datamodel.ResponseFIR_ClassName()

def ResponseFIR_TypeInfo():
    r"""ResponseFIR_TypeInfo() -> RTTI"""
    return _datamodel.ResponseFIR_TypeInfo()

def ResponseFIR_Cast(*args):
    r"""
    ResponseFIR_Cast(BaseObject o) -> ResponseFIR
    ResponseFIR_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseFIR
    """
    return _datamodel.ResponseFIR_Cast(*args)

def ResponseFIR_ConstCast(*args):
    r"""
    ResponseFIR_ConstCast(BaseObject o) -> ResponseFIR
    ResponseFIR_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseFIR
    """
    return _datamodel.ResponseFIR_ConstCast(*args)

def ResponseFIR_Meta():
    r"""ResponseFIR_Meta() -> MetaObject"""
    return _datamodel.ResponseFIR_Meta()

def ResponseFIR_Create(*args):
    r"""
    ResponseFIR_Create() -> ResponseFIR
    ResponseFIR_Create(std::string const & publicID) -> ResponseFIR
    """
    return _datamodel.ResponseFIR_Create(*args)

def ResponseFIR_Find(publicID):
    r"""ResponseFIR_Find(std::string const & publicID) -> ResponseFIR"""
    return _datamodel.ResponseFIR_Find(publicID)

class ResponseIIRIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ResponseIIRIndex 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__(ResponseIIRIndex self) -> ResponseIIRIndex
        __init__(ResponseIIRIndex self, std::string const & name) -> ResponseIIRIndex
        __init__(ResponseIIRIndex self, ResponseIIRIndex arg2) -> ResponseIIRIndex
        """
        _datamodel.ResponseIIRIndex_swiginit(self, _datamodel.new_ResponseIIRIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ResponseIIRIndex self, ResponseIIRIndex arg2) -> bool"""
        return _datamodel.ResponseIIRIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ResponseIIRIndex self, ResponseIIRIndex arg2) -> bool"""
        return _datamodel.ResponseIIRIndex___ne__(self, arg2)
    name = property(_datamodel.ResponseIIRIndex_name_get, _datamodel.ResponseIIRIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_ResponseIIRIndex

# Register ResponseIIRIndex in _datamodel:
_datamodel.ResponseIIRIndex_swigregister(ResponseIIRIndex)

class ResponseIIR(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ResponseIIR 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 _datamodel.ResponseIIR_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ResponseIIR_TypeInfo()

    def className(self):
        r"""className(ResponseIIR self) -> char const *"""
        return _datamodel.ResponseIIR_className(self)

    def typeInfo(self):
        r"""typeInfo(ResponseIIR self) -> RTTI"""
        return _datamodel.ResponseIIR_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ResponseIIR
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseIIR
        """
        return _datamodel.ResponseIIR_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ResponseIIR
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseIIR
        """
        return _datamodel.ResponseIIR_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ResponseIIR self, GenericArchive ar)"""
        return _datamodel.ResponseIIR_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ResponseIIR_Meta()

    def meta(self):
        r"""meta(ResponseIIR self) -> MetaObject"""
        return _datamodel.ResponseIIR_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ResponseIIR self, ResponseIIR other) -> ResponseIIR
        __init__(ResponseIIR self, std::string const & publicID) -> ResponseIIR
        """
        _datamodel.ResponseIIR_swiginit(self, _datamodel.new_ResponseIIR(*args))
    __swig_destroy__ = _datamodel.delete_ResponseIIR

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ResponseIIR
        Create(std::string const & publicID) -> ResponseIIR
        """
        return _datamodel.ResponseIIR_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ResponseIIR"""
        return _datamodel.ResponseIIR_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ResponseIIR self, ResponseIIR other) -> bool"""
        return _datamodel.ResponseIIR___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ResponseIIR self, ResponseIIR other) -> bool"""
        return _datamodel.ResponseIIR___ne__(self, other)

    def equal(self, other):
        r"""equal(ResponseIIR self, ResponseIIR other) -> bool"""
        return _datamodel.ResponseIIR_equal(self, other)

    def setName(self, name):
        r"""setName(ResponseIIR self, std::string const & name)"""
        return _datamodel.ResponseIIR_setName(self, name)

    def name(self):
        r"""name(ResponseIIR self) -> std::string const &"""
        return _datamodel.ResponseIIR_name(self)

    def setType(self, type):
        r"""setType(ResponseIIR self, std::string const & type)"""
        return _datamodel.ResponseIIR_setType(self, type)

    def type(self):
        r"""type(ResponseIIR self) -> std::string const &"""
        return _datamodel.ResponseIIR_type(self)

    def setGain(self, gain):
        r"""setGain(ResponseIIR self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.ResponseIIR_setGain(self, gain)

    def gain(self):
        r"""gain(ResponseIIR self) -> double"""
        return _datamodel.ResponseIIR_gain(self)

    def setGainFrequency(self, gainFrequency):
        r"""setGainFrequency(ResponseIIR self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
        return _datamodel.ResponseIIR_setGainFrequency(self, gainFrequency)

    def gainFrequency(self):
        r"""gainFrequency(ResponseIIR self) -> double"""
        return _datamodel.ResponseIIR_gainFrequency(self)

    def setDecimationFactor(self, decimationFactor):
        r"""setDecimationFactor(ResponseIIR self, Seiscomp::Core::Optional< int >::Impl const & decimationFactor)"""
        return _datamodel.ResponseIIR_setDecimationFactor(self, decimationFactor)

    def decimationFactor(self):
        r"""decimationFactor(ResponseIIR self) -> int"""
        return _datamodel.ResponseIIR_decimationFactor(self)

    def setDelay(self, delay):
        r"""setDelay(ResponseIIR self, Seiscomp::Core::Optional< double >::Impl const & delay)"""
        return _datamodel.ResponseIIR_setDelay(self, delay)

    def delay(self):
        r"""delay(ResponseIIR self) -> double"""
        return _datamodel.ResponseIIR_delay(self)

    def setCorrection(self, correction):
        r"""setCorrection(ResponseIIR self, Seiscomp::Core::Optional< double >::Impl const & correction)"""
        return _datamodel.ResponseIIR_setCorrection(self, correction)

    def correction(self):
        r"""correction(ResponseIIR self) -> double"""
        return _datamodel.ResponseIIR_correction(self)

    def setNumberOfNumerators(self, numberOfNumerators):
        r"""setNumberOfNumerators(ResponseIIR self, Seiscomp::Core::Optional< int >::Impl const & numberOfNumerators)"""
        return _datamodel.ResponseIIR_setNumberOfNumerators(self, numberOfNumerators)

    def numberOfNumerators(self):
        r"""numberOfNumerators(ResponseIIR self) -> int"""
        return _datamodel.ResponseIIR_numberOfNumerators(self)

    def setNumberOfDenominators(self, numberOfDenominators):
        r"""setNumberOfDenominators(ResponseIIR self, Seiscomp::Core::Optional< int >::Impl const & numberOfDenominators)"""
        return _datamodel.ResponseIIR_setNumberOfDenominators(self, numberOfDenominators)

    def numberOfDenominators(self):
        r"""numberOfDenominators(ResponseIIR self) -> int"""
        return _datamodel.ResponseIIR_numberOfDenominators(self)

    def setNumerators(self, numerators):
        r"""setNumerators(ResponseIIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & numerators)"""
        return _datamodel.ResponseIIR_setNumerators(self, numerators)

    def numerators(self, *args):
        r"""
        numerators(ResponseIIR self) -> RealArray
        numerators(ResponseIIR self) -> RealArray
        """
        return _datamodel.ResponseIIR_numerators(self, *args)

    def setDenominators(self, denominators):
        r"""setDenominators(ResponseIIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & denominators)"""
        return _datamodel.ResponseIIR_setDenominators(self, denominators)

    def denominators(self, *args):
        r"""
        denominators(ResponseIIR self) -> RealArray
        denominators(ResponseIIR self) -> RealArray
        """
        return _datamodel.ResponseIIR_denominators(self, *args)

    def setRemark(self, remark):
        r"""setRemark(ResponseIIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.ResponseIIR_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(ResponseIIR self) -> Blob
        remark(ResponseIIR self) -> Blob
        """
        return _datamodel.ResponseIIR_remark(self, *args)

    def index(self):
        r"""index(ResponseIIR self) -> ResponseIIRIndex"""
        return _datamodel.ResponseIIR_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ResponseIIR self, ResponseIIR lhs) -> bool"""
        return _datamodel.ResponseIIR_equalIndex(self, lhs)

    def inventory(self):
        r"""inventory(ResponseIIR self) -> Inventory"""
        return _datamodel.ResponseIIR_inventory(self)

    def assign(self, other):
        r"""assign(ResponseIIR self, Object other) -> bool"""
        return _datamodel.ResponseIIR_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ResponseIIR self, PublicObject parent) -> bool"""
        return _datamodel.ResponseIIR_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ResponseIIR self, PublicObject parent) -> bool"""
        return _datamodel.ResponseIIR_detachFrom(self, parent)

    def detach(self):
        r"""detach(ResponseIIR self) -> bool"""
        return _datamodel.ResponseIIR_detach(self)

    def clone(self):
        r"""clone(ResponseIIR self) -> Object"""
        return _datamodel.ResponseIIR_clone(self)

    def updateChild(self, child):
        r"""updateChild(ResponseIIR self, Object child) -> bool"""
        return _datamodel.ResponseIIR_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ResponseIIR self, Visitor visitor)"""
        return _datamodel.ResponseIIR_accept(self, visitor)

# Register ResponseIIR in _datamodel:
_datamodel.ResponseIIR_swigregister(ResponseIIR)

def ResponseIIR_ClassName():
    r"""ResponseIIR_ClassName() -> char const *"""
    return _datamodel.ResponseIIR_ClassName()

def ResponseIIR_TypeInfo():
    r"""ResponseIIR_TypeInfo() -> RTTI"""
    return _datamodel.ResponseIIR_TypeInfo()

def ResponseIIR_Cast(*args):
    r"""
    ResponseIIR_Cast(BaseObject o) -> ResponseIIR
    ResponseIIR_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseIIR
    """
    return _datamodel.ResponseIIR_Cast(*args)

def ResponseIIR_ConstCast(*args):
    r"""
    ResponseIIR_ConstCast(BaseObject o) -> ResponseIIR
    ResponseIIR_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseIIR
    """
    return _datamodel.ResponseIIR_ConstCast(*args)

def ResponseIIR_Meta():
    r"""ResponseIIR_Meta() -> MetaObject"""
    return _datamodel.ResponseIIR_Meta()

def ResponseIIR_Create(*args):
    r"""
    ResponseIIR_Create() -> ResponseIIR
    ResponseIIR_Create(std::string const & publicID) -> ResponseIIR
    """
    return _datamodel.ResponseIIR_Create(*args)

def ResponseIIR_Find(publicID):
    r"""ResponseIIR_Find(std::string const & publicID) -> ResponseIIR"""
    return _datamodel.ResponseIIR_Find(publicID)

class DataloggerCalibrationIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::DataloggerCalibrationIndex 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__(DataloggerCalibrationIndex self) -> DataloggerCalibrationIndex
        __init__(DataloggerCalibrationIndex self, std::string const & serialNumber, int channel, Time start) -> DataloggerCalibrationIndex
        __init__(DataloggerCalibrationIndex self, DataloggerCalibrationIndex arg2) -> DataloggerCalibrationIndex
        """
        _datamodel.DataloggerCalibrationIndex_swiginit(self, _datamodel.new_DataloggerCalibrationIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(DataloggerCalibrationIndex self, DataloggerCalibrationIndex arg2) -> bool"""
        return _datamodel.DataloggerCalibrationIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(DataloggerCalibrationIndex self, DataloggerCalibrationIndex arg2) -> bool"""
        return _datamodel.DataloggerCalibrationIndex___ne__(self, arg2)
    serialNumber = property(_datamodel.DataloggerCalibrationIndex_serialNumber_get, _datamodel.DataloggerCalibrationIndex_serialNumber_set, doc=r"""serialNumber : std::string""")
    channel = property(_datamodel.DataloggerCalibrationIndex_channel_get, _datamodel.DataloggerCalibrationIndex_channel_set, doc=r"""channel : int""")
    start = property(_datamodel.DataloggerCalibrationIndex_start_get, _datamodel.DataloggerCalibrationIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_DataloggerCalibrationIndex

# Register DataloggerCalibrationIndex in _datamodel:
_datamodel.DataloggerCalibrationIndex_swigregister(DataloggerCalibrationIndex)

class DataloggerCalibration(Object):
    r"""Proxy of C++ Seiscomp::DataModel::DataloggerCalibration 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 _datamodel.DataloggerCalibration_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.DataloggerCalibration_TypeInfo()

    def className(self):
        r"""className(DataloggerCalibration self) -> char const *"""
        return _datamodel.DataloggerCalibration_className(self)

    def typeInfo(self):
        r"""typeInfo(DataloggerCalibration self) -> RTTI"""
        return _datamodel.DataloggerCalibration_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DataloggerCalibration
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DataloggerCalibration
        """
        return _datamodel.DataloggerCalibration_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DataloggerCalibration
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataloggerCalibration
        """
        return _datamodel.DataloggerCalibration_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(DataloggerCalibration self, GenericArchive ar)"""
        return _datamodel.DataloggerCalibration_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.DataloggerCalibration_Meta()

    def meta(self):
        r"""meta(DataloggerCalibration self) -> MetaObject"""
        return _datamodel.DataloggerCalibration_meta(self)

    def __init__(self, *args):
        r"""
        __init__(DataloggerCalibration self) -> DataloggerCalibration
        __init__(DataloggerCalibration self, DataloggerCalibration other) -> DataloggerCalibration
        """
        _datamodel.DataloggerCalibration_swiginit(self, _datamodel.new_DataloggerCalibration(*args))
    __swig_destroy__ = _datamodel.delete_DataloggerCalibration

    def __eq__(self, other):
        r"""__eq__(DataloggerCalibration self, DataloggerCalibration other) -> bool"""
        return _datamodel.DataloggerCalibration___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(DataloggerCalibration self, DataloggerCalibration other) -> bool"""
        return _datamodel.DataloggerCalibration___ne__(self, other)

    def equal(self, other):
        r"""equal(DataloggerCalibration self, DataloggerCalibration other) -> bool"""
        return _datamodel.DataloggerCalibration_equal(self, other)

    def setSerialNumber(self, serialNumber):
        r"""setSerialNumber(DataloggerCalibration self, std::string const & serialNumber)"""
        return _datamodel.DataloggerCalibration_setSerialNumber(self, serialNumber)

    def serialNumber(self):
        r"""serialNumber(DataloggerCalibration self) -> std::string const &"""
        return _datamodel.DataloggerCalibration_serialNumber(self)

    def setChannel(self, channel):
        r"""setChannel(DataloggerCalibration self, int channel)"""
        return _datamodel.DataloggerCalibration_setChannel(self, channel)

    def channel(self):
        r"""channel(DataloggerCalibration self) -> int"""
        return _datamodel.DataloggerCalibration_channel(self)

    def setStart(self, start):
        r"""setStart(DataloggerCalibration self, Time start)"""
        return _datamodel.DataloggerCalibration_setStart(self, start)

    def start(self):
        r"""start(DataloggerCalibration self) -> Time"""
        return _datamodel.DataloggerCalibration_start(self)

    def setEnd(self, end):
        r"""setEnd(DataloggerCalibration self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.DataloggerCalibration_setEnd(self, end)

    def end(self):
        r"""end(DataloggerCalibration self) -> Time"""
        return _datamodel.DataloggerCalibration_end(self)

    def setGain(self, gain):
        r"""setGain(DataloggerCalibration self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.DataloggerCalibration_setGain(self, gain)

    def gain(self):
        r"""gain(DataloggerCalibration self) -> double"""
        return _datamodel.DataloggerCalibration_gain(self)

    def setGainFrequency(self, gainFrequency):
        r"""setGainFrequency(DataloggerCalibration self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
        return _datamodel.DataloggerCalibration_setGainFrequency(self, gainFrequency)

    def gainFrequency(self):
        r"""gainFrequency(DataloggerCalibration self) -> double"""
        return _datamodel.DataloggerCalibration_gainFrequency(self)

    def setRemark(self, remark):
        r"""setRemark(DataloggerCalibration self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.DataloggerCalibration_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(DataloggerCalibration self) -> Blob
        remark(DataloggerCalibration self) -> Blob
        """
        return _datamodel.DataloggerCalibration_remark(self, *args)

    def index(self):
        r"""index(DataloggerCalibration self) -> DataloggerCalibrationIndex"""
        return _datamodel.DataloggerCalibration_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(DataloggerCalibration self, DataloggerCalibration lhs) -> bool"""
        return _datamodel.DataloggerCalibration_equalIndex(self, lhs)

    def datalogger(self):
        r"""datalogger(DataloggerCalibration self) -> Datalogger"""
        return _datamodel.DataloggerCalibration_datalogger(self)

    def assign(self, other):
        r"""assign(DataloggerCalibration self, Object other) -> bool"""
        return _datamodel.DataloggerCalibration_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(DataloggerCalibration self, PublicObject parent) -> bool"""
        return _datamodel.DataloggerCalibration_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(DataloggerCalibration self, PublicObject parent) -> bool"""
        return _datamodel.DataloggerCalibration_detachFrom(self, parent)

    def detach(self):
        r"""detach(DataloggerCalibration self) -> bool"""
        return _datamodel.DataloggerCalibration_detach(self)

    def clone(self):
        r"""clone(DataloggerCalibration self) -> Object"""
        return _datamodel.DataloggerCalibration_clone(self)

    def accept(self, visitor):
        r"""accept(DataloggerCalibration self, Visitor visitor)"""
        return _datamodel.DataloggerCalibration_accept(self, visitor)

# Register DataloggerCalibration in _datamodel:
_datamodel.DataloggerCalibration_swigregister(DataloggerCalibration)

def DataloggerCalibration_ClassName():
    r"""DataloggerCalibration_ClassName() -> char const *"""
    return _datamodel.DataloggerCalibration_ClassName()

def DataloggerCalibration_TypeInfo():
    r"""DataloggerCalibration_TypeInfo() -> RTTI"""
    return _datamodel.DataloggerCalibration_TypeInfo()

def DataloggerCalibration_Cast(*args):
    r"""
    DataloggerCalibration_Cast(BaseObject o) -> DataloggerCalibration
    DataloggerCalibration_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataloggerCalibration
    """
    return _datamodel.DataloggerCalibration_Cast(*args)

def DataloggerCalibration_ConstCast(*args):
    r"""
    DataloggerCalibration_ConstCast(BaseObject o) -> DataloggerCalibration
    DataloggerCalibration_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataloggerCalibration
    """
    return _datamodel.DataloggerCalibration_ConstCast(*args)

def DataloggerCalibration_Meta():
    r"""DataloggerCalibration_Meta() -> MetaObject"""
    return _datamodel.DataloggerCalibration_Meta()

class DecimationIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::DecimationIndex 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__(DecimationIndex self) -> DecimationIndex
        __init__(DecimationIndex self, int sampleRateNumerator, int sampleRateDenominator) -> DecimationIndex
        __init__(DecimationIndex self, DecimationIndex arg2) -> DecimationIndex
        """
        _datamodel.DecimationIndex_swiginit(self, _datamodel.new_DecimationIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(DecimationIndex self, DecimationIndex arg2) -> bool"""
        return _datamodel.DecimationIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(DecimationIndex self, DecimationIndex arg2) -> bool"""
        return _datamodel.DecimationIndex___ne__(self, arg2)
    sampleRateNumerator = property(_datamodel.DecimationIndex_sampleRateNumerator_get, _datamodel.DecimationIndex_sampleRateNumerator_set, doc=r"""sampleRateNumerator : int""")
    sampleRateDenominator = property(_datamodel.DecimationIndex_sampleRateDenominator_get, _datamodel.DecimationIndex_sampleRateDenominator_set, doc=r"""sampleRateDenominator : int""")
    __swig_destroy__ = _datamodel.delete_DecimationIndex

# Register DecimationIndex in _datamodel:
_datamodel.DecimationIndex_swigregister(DecimationIndex)

class Decimation(Object):
    r"""Proxy of C++ Seiscomp::DataModel::Decimation 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 _datamodel.Decimation_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Decimation_TypeInfo()

    def className(self):
        r"""className(Decimation self) -> char const *"""
        return _datamodel.Decimation_className(self)

    def typeInfo(self):
        r"""typeInfo(Decimation self) -> RTTI"""
        return _datamodel.Decimation_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Decimation
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Decimation
        """
        return _datamodel.Decimation_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Decimation
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Decimation
        """
        return _datamodel.Decimation_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Decimation self, GenericArchive ar)"""
        return _datamodel.Decimation_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Decimation_Meta()

    def meta(self):
        r"""meta(Decimation self) -> MetaObject"""
        return _datamodel.Decimation_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Decimation self) -> Decimation
        __init__(Decimation self, Decimation other) -> Decimation
        """
        _datamodel.Decimation_swiginit(self, _datamodel.new_Decimation(*args))
    __swig_destroy__ = _datamodel.delete_Decimation

    def __eq__(self, other):
        r"""__eq__(Decimation self, Decimation other) -> bool"""
        return _datamodel.Decimation___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Decimation self, Decimation other) -> bool"""
        return _datamodel.Decimation___ne__(self, other)

    def equal(self, other):
        r"""equal(Decimation self, Decimation other) -> bool"""
        return _datamodel.Decimation_equal(self, other)

    def setSampleRateNumerator(self, sampleRateNumerator):
        r"""setSampleRateNumerator(Decimation self, int sampleRateNumerator)"""
        return _datamodel.Decimation_setSampleRateNumerator(self, sampleRateNumerator)

    def sampleRateNumerator(self):
        r"""sampleRateNumerator(Decimation self) -> int"""
        return _datamodel.Decimation_sampleRateNumerator(self)

    def setSampleRateDenominator(self, sampleRateDenominator):
        r"""setSampleRateDenominator(Decimation self, int sampleRateDenominator)"""
        return _datamodel.Decimation_setSampleRateDenominator(self, sampleRateDenominator)

    def sampleRateDenominator(self):
        r"""sampleRateDenominator(Decimation self) -> int"""
        return _datamodel.Decimation_sampleRateDenominator(self)

    def setAnalogueFilterChain(self, analogueFilterChain):
        r"""setAnalogueFilterChain(Decimation self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & analogueFilterChain)"""
        return _datamodel.Decimation_setAnalogueFilterChain(self, analogueFilterChain)

    def analogueFilterChain(self, *args):
        r"""
        analogueFilterChain(Decimation self) -> Blob
        analogueFilterChain(Decimation self) -> Blob
        """
        return _datamodel.Decimation_analogueFilterChain(self, *args)

    def setDigitalFilterChain(self, digitalFilterChain):
        r"""setDigitalFilterChain(Decimation self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & digitalFilterChain)"""
        return _datamodel.Decimation_setDigitalFilterChain(self, digitalFilterChain)

    def digitalFilterChain(self, *args):
        r"""
        digitalFilterChain(Decimation self) -> Blob
        digitalFilterChain(Decimation self) -> Blob
        """
        return _datamodel.Decimation_digitalFilterChain(self, *args)

    def index(self):
        r"""index(Decimation self) -> DecimationIndex"""
        return _datamodel.Decimation_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Decimation self, Decimation lhs) -> bool"""
        return _datamodel.Decimation_equalIndex(self, lhs)

    def datalogger(self):
        r"""datalogger(Decimation self) -> Datalogger"""
        return _datamodel.Decimation_datalogger(self)

    def assign(self, other):
        r"""assign(Decimation self, Object other) -> bool"""
        return _datamodel.Decimation_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Decimation self, PublicObject parent) -> bool"""
        return _datamodel.Decimation_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Decimation self, PublicObject parent) -> bool"""
        return _datamodel.Decimation_detachFrom(self, parent)

    def detach(self):
        r"""detach(Decimation self) -> bool"""
        return _datamodel.Decimation_detach(self)

    def clone(self):
        r"""clone(Decimation self) -> Object"""
        return _datamodel.Decimation_clone(self)

    def accept(self, visitor):
        r"""accept(Decimation self, Visitor visitor)"""
        return _datamodel.Decimation_accept(self, visitor)

# Register Decimation in _datamodel:
_datamodel.Decimation_swigregister(Decimation)

def Decimation_ClassName():
    r"""Decimation_ClassName() -> char const *"""
    return _datamodel.Decimation_ClassName()

def Decimation_TypeInfo():
    r"""Decimation_TypeInfo() -> RTTI"""
    return _datamodel.Decimation_TypeInfo()

def Decimation_Cast(*args):
    r"""
    Decimation_Cast(BaseObject o) -> Decimation
    Decimation_Cast(Seiscomp::Core::BaseObjectPtr o) -> Decimation
    """
    return _datamodel.Decimation_Cast(*args)

def Decimation_ConstCast(*args):
    r"""
    Decimation_ConstCast(BaseObject o) -> Decimation
    Decimation_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Decimation
    """
    return _datamodel.Decimation_ConstCast(*args)

def Decimation_Meta():
    r"""Decimation_Meta() -> MetaObject"""
    return _datamodel.Decimation_Meta()

class DataloggerIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::DataloggerIndex 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__(DataloggerIndex self) -> DataloggerIndex
        __init__(DataloggerIndex self, std::string const & name) -> DataloggerIndex
        __init__(DataloggerIndex self, DataloggerIndex arg2) -> DataloggerIndex
        """
        _datamodel.DataloggerIndex_swiginit(self, _datamodel.new_DataloggerIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(DataloggerIndex self, DataloggerIndex arg2) -> bool"""
        return _datamodel.DataloggerIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(DataloggerIndex self, DataloggerIndex arg2) -> bool"""
        return _datamodel.DataloggerIndex___ne__(self, arg2)
    name = property(_datamodel.DataloggerIndex_name_get, _datamodel.DataloggerIndex_name_set, doc=r"""name : std::string""")
    __swig_destroy__ = _datamodel.delete_DataloggerIndex

# Register DataloggerIndex in _datamodel:
_datamodel.DataloggerIndex_swigregister(DataloggerIndex)

class Datalogger(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Datalogger 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 _datamodel.Datalogger_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Datalogger_TypeInfo()

    def className(self):
        r"""className(Datalogger self) -> char const *"""
        return _datamodel.Datalogger_className(self)

    def typeInfo(self):
        r"""typeInfo(Datalogger self) -> RTTI"""
        return _datamodel.Datalogger_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Datalogger
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Datalogger
        """
        return _datamodel.Datalogger_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Datalogger
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Datalogger
        """
        return _datamodel.Datalogger_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Datalogger self, GenericArchive ar)"""
        return _datamodel.Datalogger_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Datalogger_Meta()

    def meta(self):
        r"""meta(Datalogger self) -> MetaObject"""
        return _datamodel.Datalogger_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Datalogger self, Datalogger other) -> Datalogger
        __init__(Datalogger self, std::string const & publicID) -> Datalogger
        """
        _datamodel.Datalogger_swiginit(self, _datamodel.new_Datalogger(*args))
    __swig_destroy__ = _datamodel.delete_Datalogger

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Datalogger
        Create(std::string const & publicID) -> Datalogger
        """
        return _datamodel.Datalogger_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Datalogger"""
        return _datamodel.Datalogger_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Datalogger self, Datalogger other) -> bool"""
        return _datamodel.Datalogger___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Datalogger self, Datalogger other) -> bool"""
        return _datamodel.Datalogger___ne__(self, other)

    def equal(self, other):
        r"""equal(Datalogger self, Datalogger other) -> bool"""
        return _datamodel.Datalogger_equal(self, other)

    def setName(self, name):
        r"""setName(Datalogger self, std::string const & name)"""
        return _datamodel.Datalogger_setName(self, name)

    def name(self):
        r"""name(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_name(self)

    def setDescription(self, description):
        r"""setDescription(Datalogger self, std::string const & description)"""
        return _datamodel.Datalogger_setDescription(self, description)

    def description(self):
        r"""description(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_description(self)

    def setDigitizerModel(self, digitizerModel):
        r"""setDigitizerModel(Datalogger self, std::string const & digitizerModel)"""
        return _datamodel.Datalogger_setDigitizerModel(self, digitizerModel)

    def digitizerModel(self):
        r"""digitizerModel(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_digitizerModel(self)

    def setDigitizerManufacturer(self, digitizerManufacturer):
        r"""setDigitizerManufacturer(Datalogger self, std::string const & digitizerManufacturer)"""
        return _datamodel.Datalogger_setDigitizerManufacturer(self, digitizerManufacturer)

    def digitizerManufacturer(self):
        r"""digitizerManufacturer(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_digitizerManufacturer(self)

    def setRecorderModel(self, recorderModel):
        r"""setRecorderModel(Datalogger self, std::string const & recorderModel)"""
        return _datamodel.Datalogger_setRecorderModel(self, recorderModel)

    def recorderModel(self):
        r"""recorderModel(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_recorderModel(self)

    def setRecorderManufacturer(self, recorderManufacturer):
        r"""setRecorderManufacturer(Datalogger self, std::string const & recorderManufacturer)"""
        return _datamodel.Datalogger_setRecorderManufacturer(self, recorderManufacturer)

    def recorderManufacturer(self):
        r"""recorderManufacturer(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_recorderManufacturer(self)

    def setClockModel(self, clockModel):
        r"""setClockModel(Datalogger self, std::string const & clockModel)"""
        return _datamodel.Datalogger_setClockModel(self, clockModel)

    def clockModel(self):
        r"""clockModel(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_clockModel(self)

    def setClockManufacturer(self, clockManufacturer):
        r"""setClockManufacturer(Datalogger self, std::string const & clockManufacturer)"""
        return _datamodel.Datalogger_setClockManufacturer(self, clockManufacturer)

    def clockManufacturer(self):
        r"""clockManufacturer(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_clockManufacturer(self)

    def setClockType(self, clockType):
        r"""setClockType(Datalogger self, std::string const & clockType)"""
        return _datamodel.Datalogger_setClockType(self, clockType)

    def clockType(self):
        r"""clockType(Datalogger self) -> std::string const &"""
        return _datamodel.Datalogger_clockType(self)

    def setGain(self, gain):
        r"""setGain(Datalogger self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.Datalogger_setGain(self, gain)

    def gain(self):
        r"""gain(Datalogger self) -> double"""
        return _datamodel.Datalogger_gain(self)

    def setMaxClockDrift(self, maxClockDrift):
        r"""setMaxClockDrift(Datalogger self, Seiscomp::Core::Optional< double >::Impl const & maxClockDrift)"""
        return _datamodel.Datalogger_setMaxClockDrift(self, maxClockDrift)

    def maxClockDrift(self):
        r"""maxClockDrift(Datalogger self) -> double"""
        return _datamodel.Datalogger_maxClockDrift(self)

    def setRemark(self, remark):
        r"""setRemark(Datalogger self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.Datalogger_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(Datalogger self) -> Blob
        remark(Datalogger self) -> Blob
        """
        return _datamodel.Datalogger_remark(self, *args)

    def index(self):
        r"""index(Datalogger self) -> DataloggerIndex"""
        return _datamodel.Datalogger_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Datalogger self, Datalogger lhs) -> bool"""
        return _datamodel.Datalogger_equalIndex(self, lhs)

    def add(self, *args):
        r"""
        add(Datalogger self, DataloggerCalibration obj) -> bool
        add(Datalogger self, Decimation obj) -> bool
        """
        return _datamodel.Datalogger_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Datalogger self, DataloggerCalibration obj) -> bool
        remove(Datalogger self, Decimation obj) -> bool
        """
        return _datamodel.Datalogger_remove(self, *args)

    def removeDataloggerCalibration(self, *args):
        r"""
        removeDataloggerCalibration(Datalogger self, size_t i) -> bool
        removeDataloggerCalibration(Datalogger self, DataloggerCalibrationIndex i) -> bool
        """
        return _datamodel.Datalogger_removeDataloggerCalibration(self, *args)

    def removeDecimation(self, *args):
        r"""
        removeDecimation(Datalogger self, size_t i) -> bool
        removeDecimation(Datalogger self, DecimationIndex i) -> bool
        """
        return _datamodel.Datalogger_removeDecimation(self, *args)

    def dataloggerCalibrationCount(self):
        r"""dataloggerCalibrationCount(Datalogger self) -> size_t"""
        return _datamodel.Datalogger_dataloggerCalibrationCount(self)

    def decimationCount(self):
        r"""decimationCount(Datalogger self) -> size_t"""
        return _datamodel.Datalogger_decimationCount(self)

    def dataloggerCalibration(self, *args):
        r"""
        dataloggerCalibration(Datalogger self, size_t i) -> DataloggerCalibration
        dataloggerCalibration(Datalogger self, DataloggerCalibrationIndex i) -> DataloggerCalibration
        """
        return _datamodel.Datalogger_dataloggerCalibration(self, *args)

    def decimation(self, *args):
        r"""
        decimation(Datalogger self, size_t i) -> Decimation
        decimation(Datalogger self, DecimationIndex i) -> Decimation
        """
        return _datamodel.Datalogger_decimation(self, *args)

    def inventory(self):
        r"""inventory(Datalogger self) -> Inventory"""
        return _datamodel.Datalogger_inventory(self)

    def assign(self, other):
        r"""assign(Datalogger self, Object other) -> bool"""
        return _datamodel.Datalogger_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Datalogger self, PublicObject parent) -> bool"""
        return _datamodel.Datalogger_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Datalogger self, PublicObject parent) -> bool"""
        return _datamodel.Datalogger_detachFrom(self, parent)

    def detach(self):
        r"""detach(Datalogger self) -> bool"""
        return _datamodel.Datalogger_detach(self)

    def clone(self):
        r"""clone(Datalogger self) -> Object"""
        return _datamodel.Datalogger_clone(self)

    def updateChild(self, child):
        r"""updateChild(Datalogger self, Object child) -> bool"""
        return _datamodel.Datalogger_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Datalogger self, Visitor visitor)"""
        return _datamodel.Datalogger_accept(self, visitor)

# Register Datalogger in _datamodel:
_datamodel.Datalogger_swigregister(Datalogger)

def Datalogger_ClassName():
    r"""Datalogger_ClassName() -> char const *"""
    return _datamodel.Datalogger_ClassName()

def Datalogger_TypeInfo():
    r"""Datalogger_TypeInfo() -> RTTI"""
    return _datamodel.Datalogger_TypeInfo()

def Datalogger_Cast(*args):
    r"""
    Datalogger_Cast(BaseObject o) -> Datalogger
    Datalogger_Cast(Seiscomp::Core::BaseObjectPtr o) -> Datalogger
    """
    return _datamodel.Datalogger_Cast(*args)

def Datalogger_ConstCast(*args):
    r"""
    Datalogger_ConstCast(BaseObject o) -> Datalogger
    Datalogger_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Datalogger
    """
    return _datamodel.Datalogger_ConstCast(*args)

def Datalogger_Meta():
    r"""Datalogger_Meta() -> MetaObject"""
    return _datamodel.Datalogger_Meta()

def Datalogger_Create(*args):
    r"""
    Datalogger_Create() -> Datalogger
    Datalogger_Create(std::string const & publicID) -> Datalogger
    """
    return _datamodel.Datalogger_Create(*args)

def Datalogger_Find(publicID):
    r"""Datalogger_Find(std::string const & publicID) -> Datalogger"""
    return _datamodel.Datalogger_Find(publicID)

class AuxStreamIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::AuxStreamIndex 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__(AuxStreamIndex self) -> AuxStreamIndex
        __init__(AuxStreamIndex self, std::string const & code, Time start) -> AuxStreamIndex
        __init__(AuxStreamIndex self, AuxStreamIndex arg2) -> AuxStreamIndex
        """
        _datamodel.AuxStreamIndex_swiginit(self, _datamodel.new_AuxStreamIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(AuxStreamIndex self, AuxStreamIndex arg2) -> bool"""
        return _datamodel.AuxStreamIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(AuxStreamIndex self, AuxStreamIndex arg2) -> bool"""
        return _datamodel.AuxStreamIndex___ne__(self, arg2)
    code = property(_datamodel.AuxStreamIndex_code_get, _datamodel.AuxStreamIndex_code_set, doc=r"""code : std::string""")
    start = property(_datamodel.AuxStreamIndex_start_get, _datamodel.AuxStreamIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_AuxStreamIndex

# Register AuxStreamIndex in _datamodel:
_datamodel.AuxStreamIndex_swigregister(AuxStreamIndex)

class AuxStream(Object):
    r"""Proxy of C++ Seiscomp::DataModel::AuxStream 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 _datamodel.AuxStream_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.AuxStream_TypeInfo()

    def className(self):
        r"""className(AuxStream self) -> char const *"""
        return _datamodel.AuxStream_className(self)

    def typeInfo(self):
        r"""typeInfo(AuxStream self) -> RTTI"""
        return _datamodel.AuxStream_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> AuxStream
        Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxStream
        """
        return _datamodel.AuxStream_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> AuxStream
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxStream
        """
        return _datamodel.AuxStream_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(AuxStream self, GenericArchive ar)"""
        return _datamodel.AuxStream_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.AuxStream_Meta()

    def meta(self):
        r"""meta(AuxStream self) -> MetaObject"""
        return _datamodel.AuxStream_meta(self)

    def __init__(self, *args):
        r"""
        __init__(AuxStream self) -> AuxStream
        __init__(AuxStream self, AuxStream other) -> AuxStream
        """
        _datamodel.AuxStream_swiginit(self, _datamodel.new_AuxStream(*args))
    __swig_destroy__ = _datamodel.delete_AuxStream

    def __eq__(self, other):
        r"""__eq__(AuxStream self, AuxStream other) -> bool"""
        return _datamodel.AuxStream___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(AuxStream self, AuxStream other) -> bool"""
        return _datamodel.AuxStream___ne__(self, other)

    def equal(self, other):
        r"""equal(AuxStream self, AuxStream other) -> bool"""
        return _datamodel.AuxStream_equal(self, other)

    def setCode(self, code):
        r"""setCode(AuxStream self, std::string const & code)"""
        return _datamodel.AuxStream_setCode(self, code)

    def code(self):
        r"""code(AuxStream self) -> std::string const &"""
        return _datamodel.AuxStream_code(self)

    def setStart(self, start):
        r"""setStart(AuxStream self, Time start)"""
        return _datamodel.AuxStream_setStart(self, start)

    def start(self):
        r"""start(AuxStream self) -> Time"""
        return _datamodel.AuxStream_start(self)

    def setEnd(self, end):
        r"""setEnd(AuxStream self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.AuxStream_setEnd(self, end)

    def end(self):
        r"""end(AuxStream self) -> Time"""
        return _datamodel.AuxStream_end(self)

    def setDevice(self, device):
        r"""setDevice(AuxStream self, std::string const & device)"""
        return _datamodel.AuxStream_setDevice(self, device)

    def device(self):
        r"""device(AuxStream self) -> std::string const &"""
        return _datamodel.AuxStream_device(self)

    def setDeviceSerialNumber(self, deviceSerialNumber):
        r"""setDeviceSerialNumber(AuxStream self, std::string const & deviceSerialNumber)"""
        return _datamodel.AuxStream_setDeviceSerialNumber(self, deviceSerialNumber)

    def deviceSerialNumber(self):
        r"""deviceSerialNumber(AuxStream self) -> std::string const &"""
        return _datamodel.AuxStream_deviceSerialNumber(self)

    def setSource(self, source):
        r"""setSource(AuxStream self, std::string const & source)"""
        return _datamodel.AuxStream_setSource(self, source)

    def source(self):
        r"""source(AuxStream self) -> std::string const &"""
        return _datamodel.AuxStream_source(self)

    def setFormat(self, format):
        r"""setFormat(AuxStream self, std::string const & format)"""
        return _datamodel.AuxStream_setFormat(self, format)

    def format(self):
        r"""format(AuxStream self) -> std::string const &"""
        return _datamodel.AuxStream_format(self)

    def setFlags(self, flags):
        r"""setFlags(AuxStream self, std::string const & flags)"""
        return _datamodel.AuxStream_setFlags(self, flags)

    def flags(self):
        r"""flags(AuxStream self) -> std::string const &"""
        return _datamodel.AuxStream_flags(self)

    def setRestricted(self, restricted):
        r"""setRestricted(AuxStream self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
        return _datamodel.AuxStream_setRestricted(self, restricted)

    def restricted(self):
        r"""restricted(AuxStream self) -> bool"""
        return _datamodel.AuxStream_restricted(self)

    def setShared(self, shared):
        r"""setShared(AuxStream self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
        return _datamodel.AuxStream_setShared(self, shared)

    def shared(self):
        r"""shared(AuxStream self) -> bool"""
        return _datamodel.AuxStream_shared(self)

    def index(self):
        r"""index(AuxStream self) -> AuxStreamIndex"""
        return _datamodel.AuxStream_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(AuxStream self, AuxStream lhs) -> bool"""
        return _datamodel.AuxStream_equalIndex(self, lhs)

    def sensorLocation(self):
        r"""sensorLocation(AuxStream self) -> SensorLocation"""
        return _datamodel.AuxStream_sensorLocation(self)

    def assign(self, other):
        r"""assign(AuxStream self, Object other) -> bool"""
        return _datamodel.AuxStream_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(AuxStream self, PublicObject parent) -> bool"""
        return _datamodel.AuxStream_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(AuxStream self, PublicObject parent) -> bool"""
        return _datamodel.AuxStream_detachFrom(self, parent)

    def detach(self):
        r"""detach(AuxStream self) -> bool"""
        return _datamodel.AuxStream_detach(self)

    def clone(self):
        r"""clone(AuxStream self) -> Object"""
        return _datamodel.AuxStream_clone(self)

    def accept(self, visitor):
        r"""accept(AuxStream self, Visitor visitor)"""
        return _datamodel.AuxStream_accept(self, visitor)

# Register AuxStream in _datamodel:
_datamodel.AuxStream_swigregister(AuxStream)

def AuxStream_ClassName():
    r"""AuxStream_ClassName() -> char const *"""
    return _datamodel.AuxStream_ClassName()

def AuxStream_TypeInfo():
    r"""AuxStream_TypeInfo() -> RTTI"""
    return _datamodel.AuxStream_TypeInfo()

def AuxStream_Cast(*args):
    r"""
    AuxStream_Cast(BaseObject o) -> AuxStream
    AuxStream_Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxStream
    """
    return _datamodel.AuxStream_Cast(*args)

def AuxStream_ConstCast(*args):
    r"""
    AuxStream_ConstCast(BaseObject o) -> AuxStream
    AuxStream_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxStream
    """
    return _datamodel.AuxStream_ConstCast(*args)

def AuxStream_Meta():
    r"""AuxStream_Meta() -> MetaObject"""
    return _datamodel.AuxStream_Meta()

class StreamIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::StreamIndex 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__(StreamIndex self) -> StreamIndex
        __init__(StreamIndex self, std::string const & code, Time start) -> StreamIndex
        __init__(StreamIndex self, StreamIndex arg2) -> StreamIndex
        """
        _datamodel.StreamIndex_swiginit(self, _datamodel.new_StreamIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(StreamIndex self, StreamIndex arg2) -> bool"""
        return _datamodel.StreamIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(StreamIndex self, StreamIndex arg2) -> bool"""
        return _datamodel.StreamIndex___ne__(self, arg2)
    code = property(_datamodel.StreamIndex_code_get, _datamodel.StreamIndex_code_set, doc=r"""code : std::string""")
    start = property(_datamodel.StreamIndex_start_get, _datamodel.StreamIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_StreamIndex

# Register StreamIndex in _datamodel:
_datamodel.StreamIndex_swigregister(StreamIndex)

class Stream(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Stream 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 _datamodel.Stream_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Stream_TypeInfo()

    def className(self):
        r"""className(Stream self) -> char const *"""
        return _datamodel.Stream_className(self)

    def typeInfo(self):
        r"""typeInfo(Stream self) -> RTTI"""
        return _datamodel.Stream_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Stream
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Stream
        """
        return _datamodel.Stream_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Stream
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Stream
        """
        return _datamodel.Stream_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Stream self, GenericArchive ar)"""
        return _datamodel.Stream_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Stream_Meta()

    def meta(self):
        r"""meta(Stream self) -> MetaObject"""
        return _datamodel.Stream_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Stream self, Stream other) -> Stream
        __init__(Stream self, std::string const & publicID) -> Stream
        """
        _datamodel.Stream_swiginit(self, _datamodel.new_Stream(*args))
    __swig_destroy__ = _datamodel.delete_Stream

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Stream
        Create(std::string const & publicID) -> Stream
        """
        return _datamodel.Stream_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Stream"""
        return _datamodel.Stream_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Stream self, Stream other) -> bool"""
        return _datamodel.Stream___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Stream self, Stream other) -> bool"""
        return _datamodel.Stream___ne__(self, other)

    def equal(self, other):
        r"""equal(Stream self, Stream other) -> bool"""
        return _datamodel.Stream_equal(self, other)

    def setCode(self, code):
        r"""setCode(Stream self, std::string const & code)"""
        return _datamodel.Stream_setCode(self, code)

    def code(self):
        r"""code(Stream self) -> std::string const &"""
        return _datamodel.Stream_code(self)

    def setStart(self, start):
        r"""setStart(Stream self, Time start)"""
        return _datamodel.Stream_setStart(self, start)

    def start(self):
        r"""start(Stream self) -> Time"""
        return _datamodel.Stream_start(self)

    def setEnd(self, end):
        r"""setEnd(Stream self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.Stream_setEnd(self, end)

    def end(self):
        r"""end(Stream self) -> Time"""
        return _datamodel.Stream_end(self)

    def setDatalogger(self, datalogger):
        r"""setDatalogger(Stream self, std::string const & datalogger)"""
        return _datamodel.Stream_setDatalogger(self, datalogger)

    def datalogger(self):
        r"""datalogger(Stream self) -> std::string const &"""
        return _datamodel.Stream_datalogger(self)

    def setDataloggerSerialNumber(self, dataloggerSerialNumber):
        r"""setDataloggerSerialNumber(Stream self, std::string const & dataloggerSerialNumber)"""
        return _datamodel.Stream_setDataloggerSerialNumber(self, dataloggerSerialNumber)

    def dataloggerSerialNumber(self):
        r"""dataloggerSerialNumber(Stream self) -> std::string const &"""
        return _datamodel.Stream_dataloggerSerialNumber(self)

    def setDataloggerChannel(self, dataloggerChannel):
        r"""setDataloggerChannel(Stream self, Seiscomp::Core::Optional< int >::Impl const & dataloggerChannel)"""
        return _datamodel.Stream_setDataloggerChannel(self, dataloggerChannel)

    def dataloggerChannel(self):
        r"""dataloggerChannel(Stream self) -> int"""
        return _datamodel.Stream_dataloggerChannel(self)

    def setSensor(self, sensor):
        r"""setSensor(Stream self, std::string const & sensor)"""
        return _datamodel.Stream_setSensor(self, sensor)

    def sensor(self):
        r"""sensor(Stream self) -> std::string const &"""
        return _datamodel.Stream_sensor(self)

    def setSensorSerialNumber(self, sensorSerialNumber):
        r"""setSensorSerialNumber(Stream self, std::string const & sensorSerialNumber)"""
        return _datamodel.Stream_setSensorSerialNumber(self, sensorSerialNumber)

    def sensorSerialNumber(self):
        r"""sensorSerialNumber(Stream self) -> std::string const &"""
        return _datamodel.Stream_sensorSerialNumber(self)

    def setSensorChannel(self, sensorChannel):
        r"""setSensorChannel(Stream self, Seiscomp::Core::Optional< int >::Impl const & sensorChannel)"""
        return _datamodel.Stream_setSensorChannel(self, sensorChannel)

    def sensorChannel(self):
        r"""sensorChannel(Stream self) -> int"""
        return _datamodel.Stream_sensorChannel(self)

    def setClockSerialNumber(self, clockSerialNumber):
        r"""setClockSerialNumber(Stream self, std::string const & clockSerialNumber)"""
        return _datamodel.Stream_setClockSerialNumber(self, clockSerialNumber)

    def clockSerialNumber(self):
        r"""clockSerialNumber(Stream self) -> std::string const &"""
        return _datamodel.Stream_clockSerialNumber(self)

    def setSampleRateNumerator(self, sampleRateNumerator):
        r"""setSampleRateNumerator(Stream self, Seiscomp::Core::Optional< int >::Impl const & sampleRateNumerator)"""
        return _datamodel.Stream_setSampleRateNumerator(self, sampleRateNumerator)

    def sampleRateNumerator(self):
        r"""sampleRateNumerator(Stream self) -> int"""
        return _datamodel.Stream_sampleRateNumerator(self)

    def setSampleRateDenominator(self, sampleRateDenominator):
        r"""setSampleRateDenominator(Stream self, Seiscomp::Core::Optional< int >::Impl const & sampleRateDenominator)"""
        return _datamodel.Stream_setSampleRateDenominator(self, sampleRateDenominator)

    def sampleRateDenominator(self):
        r"""sampleRateDenominator(Stream self) -> int"""
        return _datamodel.Stream_sampleRateDenominator(self)

    def setDepth(self, depth):
        r"""setDepth(Stream self, Seiscomp::Core::Optional< double >::Impl const & depth)"""
        return _datamodel.Stream_setDepth(self, depth)

    def depth(self):
        r"""depth(Stream self) -> double"""
        return _datamodel.Stream_depth(self)

    def setAzimuth(self, azimuth):
        r"""setAzimuth(Stream self, Seiscomp::Core::Optional< double >::Impl const & azimuth)"""
        return _datamodel.Stream_setAzimuth(self, azimuth)

    def azimuth(self):
        r"""azimuth(Stream self) -> double"""
        return _datamodel.Stream_azimuth(self)

    def setDip(self, dip):
        r"""setDip(Stream self, Seiscomp::Core::Optional< double >::Impl const & dip)"""
        return _datamodel.Stream_setDip(self, dip)

    def dip(self):
        r"""dip(Stream self) -> double"""
        return _datamodel.Stream_dip(self)

    def setGain(self, gain):
        r"""setGain(Stream self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
        return _datamodel.Stream_setGain(self, gain)

    def gain(self):
        r"""gain(Stream self) -> double"""
        return _datamodel.Stream_gain(self)

    def setGainFrequency(self, gainFrequency):
        r"""setGainFrequency(Stream self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
        return _datamodel.Stream_setGainFrequency(self, gainFrequency)

    def gainFrequency(self):
        r"""gainFrequency(Stream self) -> double"""
        return _datamodel.Stream_gainFrequency(self)

    def setGainUnit(self, gainUnit):
        r"""setGainUnit(Stream self, std::string const & gainUnit)"""
        return _datamodel.Stream_setGainUnit(self, gainUnit)

    def gainUnit(self):
        r"""gainUnit(Stream self) -> std::string const &"""
        return _datamodel.Stream_gainUnit(self)

    def setFormat(self, format):
        r"""setFormat(Stream self, std::string const & format)"""
        return _datamodel.Stream_setFormat(self, format)

    def format(self):
        r"""format(Stream self) -> std::string const &"""
        return _datamodel.Stream_format(self)

    def setFlags(self, flags):
        r"""setFlags(Stream self, std::string const & flags)"""
        return _datamodel.Stream_setFlags(self, flags)

    def flags(self):
        r"""flags(Stream self) -> std::string const &"""
        return _datamodel.Stream_flags(self)

    def setRestricted(self, restricted):
        r"""setRestricted(Stream self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
        return _datamodel.Stream_setRestricted(self, restricted)

    def restricted(self):
        r"""restricted(Stream self) -> bool"""
        return _datamodel.Stream_restricted(self)

    def setShared(self, shared):
        r"""setShared(Stream self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
        return _datamodel.Stream_setShared(self, shared)

    def shared(self):
        r"""shared(Stream self) -> bool"""
        return _datamodel.Stream_shared(self)

    def index(self):
        r"""index(Stream self) -> StreamIndex"""
        return _datamodel.Stream_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Stream self, Stream lhs) -> bool"""
        return _datamodel.Stream_equalIndex(self, lhs)

    def add(self, obj):
        r"""add(Stream self, Comment obj) -> bool"""
        return _datamodel.Stream_add(self, obj)

    def remove(self, obj):
        r"""remove(Stream self, Comment obj) -> bool"""
        return _datamodel.Stream_remove(self, obj)

    def removeComment(self, *args):
        r"""
        removeComment(Stream self, size_t i) -> bool
        removeComment(Stream self, CommentIndex i) -> bool
        """
        return _datamodel.Stream_removeComment(self, *args)

    def commentCount(self):
        r"""commentCount(Stream self) -> size_t"""
        return _datamodel.Stream_commentCount(self)

    def comment(self, *args):
        r"""
        comment(Stream self, size_t i) -> Comment
        comment(Stream self, CommentIndex i) -> Comment
        """
        return _datamodel.Stream_comment(self, *args)

    def sensorLocation(self):
        r"""sensorLocation(Stream self) -> SensorLocation"""
        return _datamodel.Stream_sensorLocation(self)

    def assign(self, other):
        r"""assign(Stream self, Object other) -> bool"""
        return _datamodel.Stream_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Stream self, PublicObject parent) -> bool"""
        return _datamodel.Stream_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Stream self, PublicObject parent) -> bool"""
        return _datamodel.Stream_detachFrom(self, parent)

    def detach(self):
        r"""detach(Stream self) -> bool"""
        return _datamodel.Stream_detach(self)

    def clone(self):
        r"""clone(Stream self) -> Object"""
        return _datamodel.Stream_clone(self)

    def updateChild(self, child):
        r"""updateChild(Stream self, Object child) -> bool"""
        return _datamodel.Stream_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Stream self, Visitor visitor)"""
        return _datamodel.Stream_accept(self, visitor)

# Register Stream in _datamodel:
_datamodel.Stream_swigregister(Stream)

def Stream_ClassName():
    r"""Stream_ClassName() -> char const *"""
    return _datamodel.Stream_ClassName()

def Stream_TypeInfo():
    r"""Stream_TypeInfo() -> RTTI"""
    return _datamodel.Stream_TypeInfo()

def Stream_Cast(*args):
    r"""
    Stream_Cast(BaseObject o) -> Stream
    Stream_Cast(Seiscomp::Core::BaseObjectPtr o) -> Stream
    """
    return _datamodel.Stream_Cast(*args)

def Stream_ConstCast(*args):
    r"""
    Stream_ConstCast(BaseObject o) -> Stream
    Stream_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Stream
    """
    return _datamodel.Stream_ConstCast(*args)

def Stream_Meta():
    r"""Stream_Meta() -> MetaObject"""
    return _datamodel.Stream_Meta()

def Stream_Create(*args):
    r"""
    Stream_Create() -> Stream
    Stream_Create(std::string const & publicID) -> Stream
    """
    return _datamodel.Stream_Create(*args)

def Stream_Find(publicID):
    r"""Stream_Find(std::string const & publicID) -> Stream"""
    return _datamodel.Stream_Find(publicID)

class SensorLocationIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::SensorLocationIndex 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__(SensorLocationIndex self) -> SensorLocationIndex
        __init__(SensorLocationIndex self, std::string const & code, Time start) -> SensorLocationIndex
        __init__(SensorLocationIndex self, SensorLocationIndex arg2) -> SensorLocationIndex
        """
        _datamodel.SensorLocationIndex_swiginit(self, _datamodel.new_SensorLocationIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(SensorLocationIndex self, SensorLocationIndex arg2) -> bool"""
        return _datamodel.SensorLocationIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(SensorLocationIndex self, SensorLocationIndex arg2) -> bool"""
        return _datamodel.SensorLocationIndex___ne__(self, arg2)
    code = property(_datamodel.SensorLocationIndex_code_get, _datamodel.SensorLocationIndex_code_set, doc=r"""code : std::string""")
    start = property(_datamodel.SensorLocationIndex_start_get, _datamodel.SensorLocationIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_SensorLocationIndex

# Register SensorLocationIndex in _datamodel:
_datamodel.SensorLocationIndex_swigregister(SensorLocationIndex)

class SensorLocation(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::SensorLocation 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 _datamodel.SensorLocation_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.SensorLocation_TypeInfo()

    def className(self):
        r"""className(SensorLocation self) -> char const *"""
        return _datamodel.SensorLocation_className(self)

    def typeInfo(self):
        r"""typeInfo(SensorLocation self) -> RTTI"""
        return _datamodel.SensorLocation_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> SensorLocation
        Cast(Seiscomp::Core::BaseObjectPtr o) -> SensorLocation
        """
        return _datamodel.SensorLocation_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> SensorLocation
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SensorLocation
        """
        return _datamodel.SensorLocation_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(SensorLocation self, GenericArchive ar)"""
        return _datamodel.SensorLocation_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.SensorLocation_Meta()

    def meta(self):
        r"""meta(SensorLocation self) -> MetaObject"""
        return _datamodel.SensorLocation_meta(self)

    def __init__(self, *args):
        r"""
        __init__(SensorLocation self, SensorLocation other) -> SensorLocation
        __init__(SensorLocation self, std::string const & publicID) -> SensorLocation
        """
        _datamodel.SensorLocation_swiginit(self, _datamodel.new_SensorLocation(*args))
    __swig_destroy__ = _datamodel.delete_SensorLocation

    @staticmethod
    def Create(*args):
        r"""
        Create() -> SensorLocation
        Create(std::string const & publicID) -> SensorLocation
        """
        return _datamodel.SensorLocation_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> SensorLocation"""
        return _datamodel.SensorLocation_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(SensorLocation self, SensorLocation other) -> bool"""
        return _datamodel.SensorLocation___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(SensorLocation self, SensorLocation other) -> bool"""
        return _datamodel.SensorLocation___ne__(self, other)

    def equal(self, other):
        r"""equal(SensorLocation self, SensorLocation other) -> bool"""
        return _datamodel.SensorLocation_equal(self, other)

    def setCode(self, code):
        r"""setCode(SensorLocation self, std::string const & code)"""
        return _datamodel.SensorLocation_setCode(self, code)

    def code(self):
        r"""code(SensorLocation self) -> std::string const &"""
        return _datamodel.SensorLocation_code(self)

    def setStart(self, start):
        r"""setStart(SensorLocation self, Time start)"""
        return _datamodel.SensorLocation_setStart(self, start)

    def start(self):
        r"""start(SensorLocation self) -> Time"""
        return _datamodel.SensorLocation_start(self)

    def setEnd(self, end):
        r"""setEnd(SensorLocation self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.SensorLocation_setEnd(self, end)

    def end(self):
        r"""end(SensorLocation self) -> Time"""
        return _datamodel.SensorLocation_end(self)

    def setLatitude(self, latitude):
        r"""setLatitude(SensorLocation self, Seiscomp::Core::Optional< double >::Impl const & latitude)"""
        return _datamodel.SensorLocation_setLatitude(self, latitude)

    def latitude(self):
        r"""latitude(SensorLocation self) -> double"""
        return _datamodel.SensorLocation_latitude(self)

    def setLongitude(self, longitude):
        r"""setLongitude(SensorLocation self, Seiscomp::Core::Optional< double >::Impl const & longitude)"""
        return _datamodel.SensorLocation_setLongitude(self, longitude)

    def longitude(self):
        r"""longitude(SensorLocation self) -> double"""
        return _datamodel.SensorLocation_longitude(self)

    def setElevation(self, elevation):
        r"""setElevation(SensorLocation self, Seiscomp::Core::Optional< double >::Impl const & elevation)"""
        return _datamodel.SensorLocation_setElevation(self, elevation)

    def elevation(self):
        r"""elevation(SensorLocation self) -> double"""
        return _datamodel.SensorLocation_elevation(self)

    def index(self):
        r"""index(SensorLocation self) -> SensorLocationIndex"""
        return _datamodel.SensorLocation_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(SensorLocation self, SensorLocation lhs) -> bool"""
        return _datamodel.SensorLocation_equalIndex(self, lhs)

    def add(self, *args):
        r"""
        add(SensorLocation self, Comment obj) -> bool
        add(SensorLocation self, AuxStream obj) -> bool
        add(SensorLocation self, Stream obj) -> bool
        """
        return _datamodel.SensorLocation_add(self, *args)

    def remove(self, *args):
        r"""
        remove(SensorLocation self, Comment obj) -> bool
        remove(SensorLocation self, AuxStream obj) -> bool
        remove(SensorLocation self, Stream obj) -> bool
        """
        return _datamodel.SensorLocation_remove(self, *args)

    def removeComment(self, *args):
        r"""
        removeComment(SensorLocation self, size_t i) -> bool
        removeComment(SensorLocation self, CommentIndex i) -> bool
        """
        return _datamodel.SensorLocation_removeComment(self, *args)

    def removeAuxStream(self, *args):
        r"""
        removeAuxStream(SensorLocation self, size_t i) -> bool
        removeAuxStream(SensorLocation self, AuxStreamIndex i) -> bool
        """
        return _datamodel.SensorLocation_removeAuxStream(self, *args)

    def removeStream(self, *args):
        r"""
        removeStream(SensorLocation self, size_t i) -> bool
        removeStream(SensorLocation self, StreamIndex i) -> bool
        """
        return _datamodel.SensorLocation_removeStream(self, *args)

    def commentCount(self):
        r"""commentCount(SensorLocation self) -> size_t"""
        return _datamodel.SensorLocation_commentCount(self)

    def auxStreamCount(self):
        r"""auxStreamCount(SensorLocation self) -> size_t"""
        return _datamodel.SensorLocation_auxStreamCount(self)

    def streamCount(self):
        r"""streamCount(SensorLocation self) -> size_t"""
        return _datamodel.SensorLocation_streamCount(self)

    def comment(self, *args):
        r"""
        comment(SensorLocation self, size_t i) -> Comment
        comment(SensorLocation self, CommentIndex i) -> Comment
        """
        return _datamodel.SensorLocation_comment(self, *args)

    def auxStream(self, *args):
        r"""
        auxStream(SensorLocation self, size_t i) -> AuxStream
        auxStream(SensorLocation self, AuxStreamIndex i) -> AuxStream
        """
        return _datamodel.SensorLocation_auxStream(self, *args)

    def stream(self, *args):
        r"""
        stream(SensorLocation self, size_t i) -> Stream
        stream(SensorLocation self, StreamIndex i) -> Stream
        """
        return _datamodel.SensorLocation_stream(self, *args)

    def findStream(self, publicID):
        r"""findStream(SensorLocation self, std::string const & publicID) -> Stream"""
        return _datamodel.SensorLocation_findStream(self, publicID)

    def station(self):
        r"""station(SensorLocation self) -> Station"""
        return _datamodel.SensorLocation_station(self)

    def assign(self, other):
        r"""assign(SensorLocation self, Object other) -> bool"""
        return _datamodel.SensorLocation_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(SensorLocation self, PublicObject parent) -> bool"""
        return _datamodel.SensorLocation_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(SensorLocation self, PublicObject parent) -> bool"""
        return _datamodel.SensorLocation_detachFrom(self, parent)

    def detach(self):
        r"""detach(SensorLocation self) -> bool"""
        return _datamodel.SensorLocation_detach(self)

    def clone(self):
        r"""clone(SensorLocation self) -> Object"""
        return _datamodel.SensorLocation_clone(self)

    def updateChild(self, child):
        r"""updateChild(SensorLocation self, Object child) -> bool"""
        return _datamodel.SensorLocation_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(SensorLocation self, Visitor visitor)"""
        return _datamodel.SensorLocation_accept(self, visitor)

# Register SensorLocation in _datamodel:
_datamodel.SensorLocation_swigregister(SensorLocation)

def SensorLocation_ClassName():
    r"""SensorLocation_ClassName() -> char const *"""
    return _datamodel.SensorLocation_ClassName()

def SensorLocation_TypeInfo():
    r"""SensorLocation_TypeInfo() -> RTTI"""
    return _datamodel.SensorLocation_TypeInfo()

def SensorLocation_Cast(*args):
    r"""
    SensorLocation_Cast(BaseObject o) -> SensorLocation
    SensorLocation_Cast(Seiscomp::Core::BaseObjectPtr o) -> SensorLocation
    """
    return _datamodel.SensorLocation_Cast(*args)

def SensorLocation_ConstCast(*args):
    r"""
    SensorLocation_ConstCast(BaseObject o) -> SensorLocation
    SensorLocation_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SensorLocation
    """
    return _datamodel.SensorLocation_ConstCast(*args)

def SensorLocation_Meta():
    r"""SensorLocation_Meta() -> MetaObject"""
    return _datamodel.SensorLocation_Meta()

def SensorLocation_Create(*args):
    r"""
    SensorLocation_Create() -> SensorLocation
    SensorLocation_Create(std::string const & publicID) -> SensorLocation
    """
    return _datamodel.SensorLocation_Create(*args)

def SensorLocation_Find(publicID):
    r"""SensorLocation_Find(std::string const & publicID) -> SensorLocation"""
    return _datamodel.SensorLocation_Find(publicID)

class StationIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::StationIndex 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__(StationIndex self) -> StationIndex
        __init__(StationIndex self, std::string const & code, Time start) -> StationIndex
        __init__(StationIndex self, StationIndex arg2) -> StationIndex
        """
        _datamodel.StationIndex_swiginit(self, _datamodel.new_StationIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(StationIndex self, StationIndex arg2) -> bool"""
        return _datamodel.StationIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(StationIndex self, StationIndex arg2) -> bool"""
        return _datamodel.StationIndex___ne__(self, arg2)
    code = property(_datamodel.StationIndex_code_get, _datamodel.StationIndex_code_set, doc=r"""code : std::string""")
    start = property(_datamodel.StationIndex_start_get, _datamodel.StationIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_StationIndex

# Register StationIndex in _datamodel:
_datamodel.StationIndex_swigregister(StationIndex)

class Station(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Station 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 _datamodel.Station_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Station_TypeInfo()

    def className(self):
        r"""className(Station self) -> char const *"""
        return _datamodel.Station_className(self)

    def typeInfo(self):
        r"""typeInfo(Station self) -> RTTI"""
        return _datamodel.Station_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Station
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Station
        """
        return _datamodel.Station_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Station
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Station
        """
        return _datamodel.Station_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Station self, GenericArchive ar)"""
        return _datamodel.Station_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Station_Meta()

    def meta(self):
        r"""meta(Station self) -> MetaObject"""
        return _datamodel.Station_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Station self, Station other) -> Station
        __init__(Station self, std::string const & publicID) -> Station
        """
        _datamodel.Station_swiginit(self, _datamodel.new_Station(*args))
    __swig_destroy__ = _datamodel.delete_Station

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Station
        Create(std::string const & publicID) -> Station
        """
        return _datamodel.Station_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Station"""
        return _datamodel.Station_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Station self, Station other) -> bool"""
        return _datamodel.Station___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Station self, Station other) -> bool"""
        return _datamodel.Station___ne__(self, other)

    def equal(self, other):
        r"""equal(Station self, Station other) -> bool"""
        return _datamodel.Station_equal(self, other)

    def setCode(self, code):
        r"""setCode(Station self, std::string const & code)"""
        return _datamodel.Station_setCode(self, code)

    def code(self):
        r"""code(Station self) -> std::string const &"""
        return _datamodel.Station_code(self)

    def setStart(self, start):
        r"""setStart(Station self, Time start)"""
        return _datamodel.Station_setStart(self, start)

    def start(self):
        r"""start(Station self) -> Time"""
        return _datamodel.Station_start(self)

    def setEnd(self, end):
        r"""setEnd(Station self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.Station_setEnd(self, end)

    def end(self):
        r"""end(Station self) -> Time"""
        return _datamodel.Station_end(self)

    def setDescription(self, description):
        r"""setDescription(Station self, std::string const & description)"""
        return _datamodel.Station_setDescription(self, description)

    def description(self):
        r"""description(Station self) -> std::string const &"""
        return _datamodel.Station_description(self)

    def setLatitude(self, latitude):
        r"""setLatitude(Station self, Seiscomp::Core::Optional< double >::Impl const & latitude)"""
        return _datamodel.Station_setLatitude(self, latitude)

    def latitude(self):
        r"""latitude(Station self) -> double"""
        return _datamodel.Station_latitude(self)

    def setLongitude(self, longitude):
        r"""setLongitude(Station self, Seiscomp::Core::Optional< double >::Impl const & longitude)"""
        return _datamodel.Station_setLongitude(self, longitude)

    def longitude(self):
        r"""longitude(Station self) -> double"""
        return _datamodel.Station_longitude(self)

    def setElevation(self, elevation):
        r"""setElevation(Station self, Seiscomp::Core::Optional< double >::Impl const & elevation)"""
        return _datamodel.Station_setElevation(self, elevation)

    def elevation(self):
        r"""elevation(Station self) -> double"""
        return _datamodel.Station_elevation(self)

    def setPlace(self, place):
        r"""setPlace(Station self, std::string const & place)"""
        return _datamodel.Station_setPlace(self, place)

    def place(self):
        r"""place(Station self) -> std::string const &"""
        return _datamodel.Station_place(self)

    def setCountry(self, country):
        r"""setCountry(Station self, std::string const & country)"""
        return _datamodel.Station_setCountry(self, country)

    def country(self):
        r"""country(Station self) -> std::string const &"""
        return _datamodel.Station_country(self)

    def setAffiliation(self, affiliation):
        r"""setAffiliation(Station self, std::string const & affiliation)"""
        return _datamodel.Station_setAffiliation(self, affiliation)

    def affiliation(self):
        r"""affiliation(Station self) -> std::string const &"""
        return _datamodel.Station_affiliation(self)

    def setType(self, type):
        r"""setType(Station self, std::string const & type)"""
        return _datamodel.Station_setType(self, type)

    def type(self):
        r"""type(Station self) -> std::string const &"""
        return _datamodel.Station_type(self)

    def setArchive(self, archive):
        r"""setArchive(Station self, std::string const & archive)"""
        return _datamodel.Station_setArchive(self, archive)

    def archive(self):
        r"""archive(Station self) -> std::string const &"""
        return _datamodel.Station_archive(self)

    def setArchiveNetworkCode(self, archiveNetworkCode):
        r"""setArchiveNetworkCode(Station self, std::string const & archiveNetworkCode)"""
        return _datamodel.Station_setArchiveNetworkCode(self, archiveNetworkCode)

    def archiveNetworkCode(self):
        r"""archiveNetworkCode(Station self) -> std::string const &"""
        return _datamodel.Station_archiveNetworkCode(self)

    def setRestricted(self, restricted):
        r"""setRestricted(Station self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
        return _datamodel.Station_setRestricted(self, restricted)

    def restricted(self):
        r"""restricted(Station self) -> bool"""
        return _datamodel.Station_restricted(self)

    def setShared(self, shared):
        r"""setShared(Station self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
        return _datamodel.Station_setShared(self, shared)

    def shared(self):
        r"""shared(Station self) -> bool"""
        return _datamodel.Station_shared(self)

    def setRemark(self, remark):
        r"""setRemark(Station self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.Station_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(Station self) -> Blob
        remark(Station self) -> Blob
        """
        return _datamodel.Station_remark(self, *args)

    def index(self):
        r"""index(Station self) -> StationIndex"""
        return _datamodel.Station_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Station self, Station lhs) -> bool"""
        return _datamodel.Station_equalIndex(self, lhs)

    def add(self, *args):
        r"""
        add(Station self, Comment obj) -> bool
        add(Station self, SensorLocation obj) -> bool
        """
        return _datamodel.Station_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Station self, Comment obj) -> bool
        remove(Station self, SensorLocation obj) -> bool
        """
        return _datamodel.Station_remove(self, *args)

    def removeComment(self, *args):
        r"""
        removeComment(Station self, size_t i) -> bool
        removeComment(Station self, CommentIndex i) -> bool
        """
        return _datamodel.Station_removeComment(self, *args)

    def removeSensorLocation(self, *args):
        r"""
        removeSensorLocation(Station self, size_t i) -> bool
        removeSensorLocation(Station self, SensorLocationIndex i) -> bool
        """
        return _datamodel.Station_removeSensorLocation(self, *args)

    def commentCount(self):
        r"""commentCount(Station self) -> size_t"""
        return _datamodel.Station_commentCount(self)

    def sensorLocationCount(self):
        r"""sensorLocationCount(Station self) -> size_t"""
        return _datamodel.Station_sensorLocationCount(self)

    def comment(self, *args):
        r"""
        comment(Station self, size_t i) -> Comment
        comment(Station self, CommentIndex i) -> Comment
        """
        return _datamodel.Station_comment(self, *args)

    def sensorLocation(self, *args):
        r"""
        sensorLocation(Station self, size_t i) -> SensorLocation
        sensorLocation(Station self, SensorLocationIndex i) -> SensorLocation
        """
        return _datamodel.Station_sensorLocation(self, *args)

    def findSensorLocation(self, publicID):
        r"""findSensorLocation(Station self, std::string const & publicID) -> SensorLocation"""
        return _datamodel.Station_findSensorLocation(self, publicID)

    def network(self):
        r"""network(Station self) -> Network"""
        return _datamodel.Station_network(self)

    def assign(self, other):
        r"""assign(Station self, Object other) -> bool"""
        return _datamodel.Station_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Station self, PublicObject parent) -> bool"""
        return _datamodel.Station_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Station self, PublicObject parent) -> bool"""
        return _datamodel.Station_detachFrom(self, parent)

    def detach(self):
        r"""detach(Station self) -> bool"""
        return _datamodel.Station_detach(self)

    def clone(self):
        r"""clone(Station self) -> Object"""
        return _datamodel.Station_clone(self)

    def updateChild(self, child):
        r"""updateChild(Station self, Object child) -> bool"""
        return _datamodel.Station_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Station self, Visitor visitor)"""
        return _datamodel.Station_accept(self, visitor)

# Register Station in _datamodel:
_datamodel.Station_swigregister(Station)

def Station_ClassName():
    r"""Station_ClassName() -> char const *"""
    return _datamodel.Station_ClassName()

def Station_TypeInfo():
    r"""Station_TypeInfo() -> RTTI"""
    return _datamodel.Station_TypeInfo()

def Station_Cast(*args):
    r"""
    Station_Cast(BaseObject o) -> Station
    Station_Cast(Seiscomp::Core::BaseObjectPtr o) -> Station
    """
    return _datamodel.Station_Cast(*args)

def Station_ConstCast(*args):
    r"""
    Station_ConstCast(BaseObject o) -> Station
    Station_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Station
    """
    return _datamodel.Station_ConstCast(*args)

def Station_Meta():
    r"""Station_Meta() -> MetaObject"""
    return _datamodel.Station_Meta()

def Station_Create(*args):
    r"""
    Station_Create() -> Station
    Station_Create(std::string const & publicID) -> Station
    """
    return _datamodel.Station_Create(*args)

def Station_Find(publicID):
    r"""Station_Find(std::string const & publicID) -> Station"""
    return _datamodel.Station_Find(publicID)

class NetworkIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::NetworkIndex 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__(NetworkIndex self) -> NetworkIndex
        __init__(NetworkIndex self, std::string const & code, Time start) -> NetworkIndex
        __init__(NetworkIndex self, NetworkIndex arg2) -> NetworkIndex
        """
        _datamodel.NetworkIndex_swiginit(self, _datamodel.new_NetworkIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(NetworkIndex self, NetworkIndex arg2) -> bool"""
        return _datamodel.NetworkIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(NetworkIndex self, NetworkIndex arg2) -> bool"""
        return _datamodel.NetworkIndex___ne__(self, arg2)
    code = property(_datamodel.NetworkIndex_code_get, _datamodel.NetworkIndex_code_set, doc=r"""code : std::string""")
    start = property(_datamodel.NetworkIndex_start_get, _datamodel.NetworkIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_NetworkIndex

# Register NetworkIndex in _datamodel:
_datamodel.NetworkIndex_swigregister(NetworkIndex)

class Network(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Network 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 _datamodel.Network_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Network_TypeInfo()

    def className(self):
        r"""className(Network self) -> char const *"""
        return _datamodel.Network_className(self)

    def typeInfo(self):
        r"""typeInfo(Network self) -> RTTI"""
        return _datamodel.Network_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Network
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Network
        """
        return _datamodel.Network_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Network
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Network
        """
        return _datamodel.Network_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Network self, GenericArchive ar)"""
        return _datamodel.Network_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Network_Meta()

    def meta(self):
        r"""meta(Network self) -> MetaObject"""
        return _datamodel.Network_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Network self, Network other) -> Network
        __init__(Network self, std::string const & publicID) -> Network
        """
        _datamodel.Network_swiginit(self, _datamodel.new_Network(*args))
    __swig_destroy__ = _datamodel.delete_Network

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Network
        Create(std::string const & publicID) -> Network
        """
        return _datamodel.Network_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Network"""
        return _datamodel.Network_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Network self, Network other) -> bool"""
        return _datamodel.Network___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Network self, Network other) -> bool"""
        return _datamodel.Network___ne__(self, other)

    def equal(self, other):
        r"""equal(Network self, Network other) -> bool"""
        return _datamodel.Network_equal(self, other)

    def setCode(self, code):
        r"""setCode(Network self, std::string const & code)"""
        return _datamodel.Network_setCode(self, code)

    def code(self):
        r"""code(Network self) -> std::string const &"""
        return _datamodel.Network_code(self)

    def setStart(self, start):
        r"""setStart(Network self, Time start)"""
        return _datamodel.Network_setStart(self, start)

    def start(self):
        r"""start(Network self) -> Time"""
        return _datamodel.Network_start(self)

    def setEnd(self, end):
        r"""setEnd(Network self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.Network_setEnd(self, end)

    def end(self):
        r"""end(Network self) -> Time"""
        return _datamodel.Network_end(self)

    def setDescription(self, description):
        r"""setDescription(Network self, std::string const & description)"""
        return _datamodel.Network_setDescription(self, description)

    def description(self):
        r"""description(Network self) -> std::string const &"""
        return _datamodel.Network_description(self)

    def setInstitutions(self, institutions):
        r"""setInstitutions(Network self, std::string const & institutions)"""
        return _datamodel.Network_setInstitutions(self, institutions)

    def institutions(self):
        r"""institutions(Network self) -> std::string const &"""
        return _datamodel.Network_institutions(self)

    def setRegion(self, region):
        r"""setRegion(Network self, std::string const & region)"""
        return _datamodel.Network_setRegion(self, region)

    def region(self):
        r"""region(Network self) -> std::string const &"""
        return _datamodel.Network_region(self)

    def setType(self, type):
        r"""setType(Network self, std::string const & type)"""
        return _datamodel.Network_setType(self, type)

    def type(self):
        r"""type(Network self) -> std::string const &"""
        return _datamodel.Network_type(self)

    def setNetClass(self, netClass):
        r"""setNetClass(Network self, std::string const & netClass)"""
        return _datamodel.Network_setNetClass(self, netClass)

    def netClass(self):
        r"""netClass(Network self) -> std::string const &"""
        return _datamodel.Network_netClass(self)

    def setArchive(self, archive):
        r"""setArchive(Network self, std::string const & archive)"""
        return _datamodel.Network_setArchive(self, archive)

    def archive(self):
        r"""archive(Network self) -> std::string const &"""
        return _datamodel.Network_archive(self)

    def setRestricted(self, restricted):
        r"""setRestricted(Network self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
        return _datamodel.Network_setRestricted(self, restricted)

    def restricted(self):
        r"""restricted(Network self) -> bool"""
        return _datamodel.Network_restricted(self)

    def setShared(self, shared):
        r"""setShared(Network self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
        return _datamodel.Network_setShared(self, shared)

    def shared(self):
        r"""shared(Network self) -> bool"""
        return _datamodel.Network_shared(self)

    def setRemark(self, remark):
        r"""setRemark(Network self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
        return _datamodel.Network_setRemark(self, remark)

    def remark(self, *args):
        r"""
        remark(Network self) -> Blob
        remark(Network self) -> Blob
        """
        return _datamodel.Network_remark(self, *args)

    def index(self):
        r"""index(Network self) -> NetworkIndex"""
        return _datamodel.Network_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Network self, Network lhs) -> bool"""
        return _datamodel.Network_equalIndex(self, lhs)

    def add(self, *args):
        r"""
        add(Network self, Comment obj) -> bool
        add(Network self, Station obj) -> bool
        """
        return _datamodel.Network_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Network self, Comment obj) -> bool
        remove(Network self, Station obj) -> bool
        """
        return _datamodel.Network_remove(self, *args)

    def removeComment(self, *args):
        r"""
        removeComment(Network self, size_t i) -> bool
        removeComment(Network self, CommentIndex i) -> bool
        """
        return _datamodel.Network_removeComment(self, *args)

    def removeStation(self, *args):
        r"""
        removeStation(Network self, size_t i) -> bool
        removeStation(Network self, StationIndex i) -> bool
        """
        return _datamodel.Network_removeStation(self, *args)

    def commentCount(self):
        r"""commentCount(Network self) -> size_t"""
        return _datamodel.Network_commentCount(self)

    def stationCount(self):
        r"""stationCount(Network self) -> size_t"""
        return _datamodel.Network_stationCount(self)

    def comment(self, *args):
        r"""
        comment(Network self, size_t i) -> Comment
        comment(Network self, CommentIndex i) -> Comment
        """
        return _datamodel.Network_comment(self, *args)

    def station(self, *args):
        r"""
        station(Network self, size_t i) -> Station
        station(Network self, StationIndex i) -> Station
        """
        return _datamodel.Network_station(self, *args)

    def findStation(self, publicID):
        r"""findStation(Network self, std::string const & publicID) -> Station"""
        return _datamodel.Network_findStation(self, publicID)

    def inventory(self):
        r"""inventory(Network self) -> Inventory"""
        return _datamodel.Network_inventory(self)

    def assign(self, other):
        r"""assign(Network self, Object other) -> bool"""
        return _datamodel.Network_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Network self, PublicObject parent) -> bool"""
        return _datamodel.Network_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Network self, PublicObject parent) -> bool"""
        return _datamodel.Network_detachFrom(self, parent)

    def detach(self):
        r"""detach(Network self) -> bool"""
        return _datamodel.Network_detach(self)

    def clone(self):
        r"""clone(Network self) -> Object"""
        return _datamodel.Network_clone(self)

    def updateChild(self, child):
        r"""updateChild(Network self, Object child) -> bool"""
        return _datamodel.Network_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Network self, Visitor visitor)"""
        return _datamodel.Network_accept(self, visitor)

# Register Network in _datamodel:
_datamodel.Network_swigregister(Network)

def Network_ClassName():
    r"""Network_ClassName() -> char const *"""
    return _datamodel.Network_ClassName()

def Network_TypeInfo():
    r"""Network_TypeInfo() -> RTTI"""
    return _datamodel.Network_TypeInfo()

def Network_Cast(*args):
    r"""
    Network_Cast(BaseObject o) -> Network
    Network_Cast(Seiscomp::Core::BaseObjectPtr o) -> Network
    """
    return _datamodel.Network_Cast(*args)

def Network_ConstCast(*args):
    r"""
    Network_ConstCast(BaseObject o) -> Network
    Network_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Network
    """
    return _datamodel.Network_ConstCast(*args)

def Network_Meta():
    r"""Network_Meta() -> MetaObject"""
    return _datamodel.Network_Meta()

def Network_Create(*args):
    r"""
    Network_Create() -> Network
    Network_Create(std::string const & publicID) -> Network
    """
    return _datamodel.Network_Create(*args)

def Network_Find(publicID):
    r"""Network_Find(std::string const & publicID) -> Network"""
    return _datamodel.Network_Find(publicID)

class Inventory(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Inventory 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 _datamodel.Inventory_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Inventory_TypeInfo()

    def className(self):
        r"""className(Inventory self) -> char const *"""
        return _datamodel.Inventory_className(self)

    def typeInfo(self):
        r"""typeInfo(Inventory self) -> RTTI"""
        return _datamodel.Inventory_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Inventory
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Inventory
        """
        return _datamodel.Inventory_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Inventory
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Inventory
        """
        return _datamodel.Inventory_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Inventory self, GenericArchive ar)"""
        return _datamodel.Inventory_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Inventory_Meta()

    def meta(self):
        r"""meta(Inventory self) -> MetaObject"""
        return _datamodel.Inventory_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Inventory self) -> Inventory
        __init__(Inventory self, Inventory other) -> Inventory
        """
        _datamodel.Inventory_swiginit(self, _datamodel.new_Inventory(*args))
    __swig_destroy__ = _datamodel.delete_Inventory

    def __eq__(self, other):
        r"""__eq__(Inventory self, Inventory other) -> bool"""
        return _datamodel.Inventory___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Inventory self, Inventory other) -> bool"""
        return _datamodel.Inventory___ne__(self, other)

    def equal(self, other):
        r"""equal(Inventory self, Inventory other) -> bool"""
        return _datamodel.Inventory_equal(self, other)

    def add(self, *args):
        r"""
        add(Inventory self, StationGroup obj) -> bool
        add(Inventory self, AuxDevice obj) -> bool
        add(Inventory self, Sensor obj) -> bool
        add(Inventory self, Datalogger obj) -> bool
        add(Inventory self, ResponsePAZ obj) -> bool
        add(Inventory self, ResponseFIR obj) -> bool
        add(Inventory self, ResponseIIR obj) -> bool
        add(Inventory self, ResponsePolynomial obj) -> bool
        add(Inventory self, ResponseFAP obj) -> bool
        add(Inventory self, Network obj) -> bool
        """
        return _datamodel.Inventory_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Inventory self, StationGroup obj) -> bool
        remove(Inventory self, AuxDevice obj) -> bool
        remove(Inventory self, Sensor obj) -> bool
        remove(Inventory self, Datalogger obj) -> bool
        remove(Inventory self, ResponsePAZ obj) -> bool
        remove(Inventory self, ResponseFIR obj) -> bool
        remove(Inventory self, ResponseIIR obj) -> bool
        remove(Inventory self, ResponsePolynomial obj) -> bool
        remove(Inventory self, ResponseFAP obj) -> bool
        remove(Inventory self, Network obj) -> bool
        """
        return _datamodel.Inventory_remove(self, *args)

    def removeStationGroup(self, *args):
        r"""
        removeStationGroup(Inventory self, size_t i) -> bool
        removeStationGroup(Inventory self, StationGroupIndex i) -> bool
        """
        return _datamodel.Inventory_removeStationGroup(self, *args)

    def removeAuxDevice(self, *args):
        r"""
        removeAuxDevice(Inventory self, size_t i) -> bool
        removeAuxDevice(Inventory self, AuxDeviceIndex i) -> bool
        """
        return _datamodel.Inventory_removeAuxDevice(self, *args)

    def removeSensor(self, *args):
        r"""
        removeSensor(Inventory self, size_t i) -> bool
        removeSensor(Inventory self, SensorIndex i) -> bool
        """
        return _datamodel.Inventory_removeSensor(self, *args)

    def removeDatalogger(self, *args):
        r"""
        removeDatalogger(Inventory self, size_t i) -> bool
        removeDatalogger(Inventory self, DataloggerIndex i) -> bool
        """
        return _datamodel.Inventory_removeDatalogger(self, *args)

    def removeResponsePAZ(self, *args):
        r"""
        removeResponsePAZ(Inventory self, size_t i) -> bool
        removeResponsePAZ(Inventory self, ResponsePAZIndex i) -> bool
        """
        return _datamodel.Inventory_removeResponsePAZ(self, *args)

    def removeResponseFIR(self, *args):
        r"""
        removeResponseFIR(Inventory self, size_t i) -> bool
        removeResponseFIR(Inventory self, ResponseFIRIndex i) -> bool
        """
        return _datamodel.Inventory_removeResponseFIR(self, *args)

    def removeResponseIIR(self, *args):
        r"""
        removeResponseIIR(Inventory self, size_t i) -> bool
        removeResponseIIR(Inventory self, ResponseIIRIndex i) -> bool
        """
        return _datamodel.Inventory_removeResponseIIR(self, *args)

    def removeResponsePolynomial(self, *args):
        r"""
        removeResponsePolynomial(Inventory self, size_t i) -> bool
        removeResponsePolynomial(Inventory self, ResponsePolynomialIndex i) -> bool
        """
        return _datamodel.Inventory_removeResponsePolynomial(self, *args)

    def removeResponseFAP(self, *args):
        r"""
        removeResponseFAP(Inventory self, size_t i) -> bool
        removeResponseFAP(Inventory self, ResponseFAPIndex i) -> bool
        """
        return _datamodel.Inventory_removeResponseFAP(self, *args)

    def removeNetwork(self, *args):
        r"""
        removeNetwork(Inventory self, size_t i) -> bool
        removeNetwork(Inventory self, NetworkIndex i) -> bool
        """
        return _datamodel.Inventory_removeNetwork(self, *args)

    def stationGroupCount(self):
        r"""stationGroupCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_stationGroupCount(self)

    def auxDeviceCount(self):
        r"""auxDeviceCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_auxDeviceCount(self)

    def sensorCount(self):
        r"""sensorCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_sensorCount(self)

    def dataloggerCount(self):
        r"""dataloggerCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_dataloggerCount(self)

    def responsePAZCount(self):
        r"""responsePAZCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_responsePAZCount(self)

    def responseFIRCount(self):
        r"""responseFIRCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_responseFIRCount(self)

    def responseIIRCount(self):
        r"""responseIIRCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_responseIIRCount(self)

    def responsePolynomialCount(self):
        r"""responsePolynomialCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_responsePolynomialCount(self)

    def responseFAPCount(self):
        r"""responseFAPCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_responseFAPCount(self)

    def networkCount(self):
        r"""networkCount(Inventory self) -> size_t"""
        return _datamodel.Inventory_networkCount(self)

    def stationGroup(self, *args):
        r"""
        stationGroup(Inventory self, size_t i) -> StationGroup
        stationGroup(Inventory self, StationGroupIndex i) -> StationGroup
        """
        return _datamodel.Inventory_stationGroup(self, *args)

    def auxDevice(self, *args):
        r"""
        auxDevice(Inventory self, size_t i) -> AuxDevice
        auxDevice(Inventory self, AuxDeviceIndex i) -> AuxDevice
        """
        return _datamodel.Inventory_auxDevice(self, *args)

    def sensor(self, *args):
        r"""
        sensor(Inventory self, size_t i) -> Sensor
        sensor(Inventory self, SensorIndex i) -> Sensor
        """
        return _datamodel.Inventory_sensor(self, *args)

    def datalogger(self, *args):
        r"""
        datalogger(Inventory self, size_t i) -> Datalogger
        datalogger(Inventory self, DataloggerIndex i) -> Datalogger
        """
        return _datamodel.Inventory_datalogger(self, *args)

    def responsePAZ(self, *args):
        r"""
        responsePAZ(Inventory self, size_t i) -> ResponsePAZ
        responsePAZ(Inventory self, ResponsePAZIndex i) -> ResponsePAZ
        """
        return _datamodel.Inventory_responsePAZ(self, *args)

    def responseFIR(self, *args):
        r"""
        responseFIR(Inventory self, size_t i) -> ResponseFIR
        responseFIR(Inventory self, ResponseFIRIndex i) -> ResponseFIR
        """
        return _datamodel.Inventory_responseFIR(self, *args)

    def responseIIR(self, *args):
        r"""
        responseIIR(Inventory self, size_t i) -> ResponseIIR
        responseIIR(Inventory self, ResponseIIRIndex i) -> ResponseIIR
        """
        return _datamodel.Inventory_responseIIR(self, *args)

    def responsePolynomial(self, *args):
        r"""
        responsePolynomial(Inventory self, size_t i) -> ResponsePolynomial
        responsePolynomial(Inventory self, ResponsePolynomialIndex i) -> ResponsePolynomial
        """
        return _datamodel.Inventory_responsePolynomial(self, *args)

    def responseFAP(self, *args):
        r"""
        responseFAP(Inventory self, size_t i) -> ResponseFAP
        responseFAP(Inventory self, ResponseFAPIndex i) -> ResponseFAP
        """
        return _datamodel.Inventory_responseFAP(self, *args)

    def network(self, *args):
        r"""
        network(Inventory self, size_t i) -> Network
        network(Inventory self, NetworkIndex i) -> Network
        """
        return _datamodel.Inventory_network(self, *args)

    def findStationGroup(self, publicID):
        r"""findStationGroup(Inventory self, std::string const & publicID) -> StationGroup"""
        return _datamodel.Inventory_findStationGroup(self, publicID)

    def findAuxDevice(self, publicID):
        r"""findAuxDevice(Inventory self, std::string const & publicID) -> AuxDevice"""
        return _datamodel.Inventory_findAuxDevice(self, publicID)

    def findSensor(self, publicID):
        r"""findSensor(Inventory self, std::string const & publicID) -> Sensor"""
        return _datamodel.Inventory_findSensor(self, publicID)

    def findDatalogger(self, publicID):
        r"""findDatalogger(Inventory self, std::string const & publicID) -> Datalogger"""
        return _datamodel.Inventory_findDatalogger(self, publicID)

    def findResponsePAZ(self, publicID):
        r"""findResponsePAZ(Inventory self, std::string const & publicID) -> ResponsePAZ"""
        return _datamodel.Inventory_findResponsePAZ(self, publicID)

    def findResponseFIR(self, publicID):
        r"""findResponseFIR(Inventory self, std::string const & publicID) -> ResponseFIR"""
        return _datamodel.Inventory_findResponseFIR(self, publicID)

    def findResponseIIR(self, publicID):
        r"""findResponseIIR(Inventory self, std::string const & publicID) -> ResponseIIR"""
        return _datamodel.Inventory_findResponseIIR(self, publicID)

    def findResponsePolynomial(self, publicID):
        r"""findResponsePolynomial(Inventory self, std::string const & publicID) -> ResponsePolynomial"""
        return _datamodel.Inventory_findResponsePolynomial(self, publicID)

    def findResponseFAP(self, publicID):
        r"""findResponseFAP(Inventory self, std::string const & publicID) -> ResponseFAP"""
        return _datamodel.Inventory_findResponseFAP(self, publicID)

    def findNetwork(self, publicID):
        r"""findNetwork(Inventory self, std::string const & publicID) -> Network"""
        return _datamodel.Inventory_findNetwork(self, publicID)

    def assign(self, other):
        r"""assign(Inventory self, Object other) -> bool"""
        return _datamodel.Inventory_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Inventory self, PublicObject parent) -> bool"""
        return _datamodel.Inventory_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Inventory self, PublicObject parent) -> bool"""
        return _datamodel.Inventory_detachFrom(self, parent)

    def detach(self):
        r"""detach(Inventory self) -> bool"""
        return _datamodel.Inventory_detach(self)

    def clone(self):
        r"""clone(Inventory self) -> Object"""
        return _datamodel.Inventory_clone(self)

    def updateChild(self, child):
        r"""updateChild(Inventory self, Object child) -> bool"""
        return _datamodel.Inventory_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Inventory self, Visitor visitor)"""
        return _datamodel.Inventory_accept(self, visitor)

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

def Inventory_ClassName():
    r"""Inventory_ClassName() -> char const *"""
    return _datamodel.Inventory_ClassName()

def Inventory_TypeInfo():
    r"""Inventory_TypeInfo() -> RTTI"""
    return _datamodel.Inventory_TypeInfo()

def Inventory_Cast(*args):
    r"""
    Inventory_Cast(BaseObject o) -> Inventory
    Inventory_Cast(Seiscomp::Core::BaseObjectPtr o) -> Inventory
    """
    return _datamodel.Inventory_Cast(*args)

def Inventory_ConstCast(*args):
    r"""
    Inventory_ConstCast(BaseObject o) -> Inventory
    Inventory_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Inventory
    """
    return _datamodel.Inventory_ConstCast(*args)

def Inventory_Meta():
    r"""Inventory_Meta() -> MetaObject"""
    return _datamodel.Inventory_Meta()

class RouteArclinkIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::RouteArclinkIndex 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__(RouteArclinkIndex self) -> RouteArclinkIndex
        __init__(RouteArclinkIndex self, std::string const & address, Time start) -> RouteArclinkIndex
        __init__(RouteArclinkIndex self, RouteArclinkIndex arg2) -> RouteArclinkIndex
        """
        _datamodel.RouteArclinkIndex_swiginit(self, _datamodel.new_RouteArclinkIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(RouteArclinkIndex self, RouteArclinkIndex arg2) -> bool"""
        return _datamodel.RouteArclinkIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(RouteArclinkIndex self, RouteArclinkIndex arg2) -> bool"""
        return _datamodel.RouteArclinkIndex___ne__(self, arg2)
    address = property(_datamodel.RouteArclinkIndex_address_get, _datamodel.RouteArclinkIndex_address_set, doc=r"""address : std::string""")
    start = property(_datamodel.RouteArclinkIndex_start_get, _datamodel.RouteArclinkIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_RouteArclinkIndex

# Register RouteArclinkIndex in _datamodel:
_datamodel.RouteArclinkIndex_swigregister(RouteArclinkIndex)

class RouteArclink(Object):
    r"""Proxy of C++ Seiscomp::DataModel::RouteArclink 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 _datamodel.RouteArclink_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.RouteArclink_TypeInfo()

    def className(self):
        r"""className(RouteArclink self) -> char const *"""
        return _datamodel.RouteArclink_className(self)

    def typeInfo(self):
        r"""typeInfo(RouteArclink self) -> RTTI"""
        return _datamodel.RouteArclink_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> RouteArclink
        Cast(Seiscomp::Core::BaseObjectPtr o) -> RouteArclink
        """
        return _datamodel.RouteArclink_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> RouteArclink
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RouteArclink
        """
        return _datamodel.RouteArclink_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(RouteArclink self, GenericArchive ar)"""
        return _datamodel.RouteArclink_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.RouteArclink_Meta()

    def meta(self):
        r"""meta(RouteArclink self) -> MetaObject"""
        return _datamodel.RouteArclink_meta(self)

    def __init__(self, *args):
        r"""
        __init__(RouteArclink self) -> RouteArclink
        __init__(RouteArclink self, RouteArclink other) -> RouteArclink
        """
        _datamodel.RouteArclink_swiginit(self, _datamodel.new_RouteArclink(*args))
    __swig_destroy__ = _datamodel.delete_RouteArclink

    def __eq__(self, other):
        r"""__eq__(RouteArclink self, RouteArclink other) -> bool"""
        return _datamodel.RouteArclink___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(RouteArclink self, RouteArclink other) -> bool"""
        return _datamodel.RouteArclink___ne__(self, other)

    def equal(self, other):
        r"""equal(RouteArclink self, RouteArclink other) -> bool"""
        return _datamodel.RouteArclink_equal(self, other)

    def setAddress(self, address):
        r"""setAddress(RouteArclink self, std::string const & address)"""
        return _datamodel.RouteArclink_setAddress(self, address)

    def address(self):
        r"""address(RouteArclink self) -> std::string const &"""
        return _datamodel.RouteArclink_address(self)

    def setStart(self, start):
        r"""setStart(RouteArclink self, Time start)"""
        return _datamodel.RouteArclink_setStart(self, start)

    def start(self):
        r"""start(RouteArclink self) -> Time"""
        return _datamodel.RouteArclink_start(self)

    def setEnd(self, end):
        r"""setEnd(RouteArclink self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.RouteArclink_setEnd(self, end)

    def end(self):
        r"""end(RouteArclink self) -> Time"""
        return _datamodel.RouteArclink_end(self)

    def setPriority(self, priority):
        r"""setPriority(RouteArclink self, Seiscomp::Core::Optional< int >::Impl const & priority)"""
        return _datamodel.RouteArclink_setPriority(self, priority)

    def priority(self):
        r"""priority(RouteArclink self) -> int"""
        return _datamodel.RouteArclink_priority(self)

    def index(self):
        r"""index(RouteArclink self) -> RouteArclinkIndex"""
        return _datamodel.RouteArclink_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(RouteArclink self, RouteArclink lhs) -> bool"""
        return _datamodel.RouteArclink_equalIndex(self, lhs)

    def route(self):
        r"""route(RouteArclink self) -> Route"""
        return _datamodel.RouteArclink_route(self)

    def assign(self, other):
        r"""assign(RouteArclink self, Object other) -> bool"""
        return _datamodel.RouteArclink_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(RouteArclink self, PublicObject parent) -> bool"""
        return _datamodel.RouteArclink_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(RouteArclink self, PublicObject parent) -> bool"""
        return _datamodel.RouteArclink_detachFrom(self, parent)

    def detach(self):
        r"""detach(RouteArclink self) -> bool"""
        return _datamodel.RouteArclink_detach(self)

    def clone(self):
        r"""clone(RouteArclink self) -> Object"""
        return _datamodel.RouteArclink_clone(self)

    def accept(self, visitor):
        r"""accept(RouteArclink self, Visitor visitor)"""
        return _datamodel.RouteArclink_accept(self, visitor)

# Register RouteArclink in _datamodel:
_datamodel.RouteArclink_swigregister(RouteArclink)

def RouteArclink_ClassName():
    r"""RouteArclink_ClassName() -> char const *"""
    return _datamodel.RouteArclink_ClassName()

def RouteArclink_TypeInfo():
    r"""RouteArclink_TypeInfo() -> RTTI"""
    return _datamodel.RouteArclink_TypeInfo()

def RouteArclink_Cast(*args):
    r"""
    RouteArclink_Cast(BaseObject o) -> RouteArclink
    RouteArclink_Cast(Seiscomp::Core::BaseObjectPtr o) -> RouteArclink
    """
    return _datamodel.RouteArclink_Cast(*args)

def RouteArclink_ConstCast(*args):
    r"""
    RouteArclink_ConstCast(BaseObject o) -> RouteArclink
    RouteArclink_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RouteArclink
    """
    return _datamodel.RouteArclink_ConstCast(*args)

def RouteArclink_Meta():
    r"""RouteArclink_Meta() -> MetaObject"""
    return _datamodel.RouteArclink_Meta()

class RouteSeedlinkIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::RouteSeedlinkIndex 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__(RouteSeedlinkIndex self) -> RouteSeedlinkIndex
        __init__(RouteSeedlinkIndex self, std::string const & address) -> RouteSeedlinkIndex
        __init__(RouteSeedlinkIndex self, RouteSeedlinkIndex arg2) -> RouteSeedlinkIndex
        """
        _datamodel.RouteSeedlinkIndex_swiginit(self, _datamodel.new_RouteSeedlinkIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(RouteSeedlinkIndex self, RouteSeedlinkIndex arg2) -> bool"""
        return _datamodel.RouteSeedlinkIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(RouteSeedlinkIndex self, RouteSeedlinkIndex arg2) -> bool"""
        return _datamodel.RouteSeedlinkIndex___ne__(self, arg2)
    address = property(_datamodel.RouteSeedlinkIndex_address_get, _datamodel.RouteSeedlinkIndex_address_set, doc=r"""address : std::string""")
    __swig_destroy__ = _datamodel.delete_RouteSeedlinkIndex

# Register RouteSeedlinkIndex in _datamodel:
_datamodel.RouteSeedlinkIndex_swigregister(RouteSeedlinkIndex)

class RouteSeedlink(Object):
    r"""Proxy of C++ Seiscomp::DataModel::RouteSeedlink 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 _datamodel.RouteSeedlink_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.RouteSeedlink_TypeInfo()

    def className(self):
        r"""className(RouteSeedlink self) -> char const *"""
        return _datamodel.RouteSeedlink_className(self)

    def typeInfo(self):
        r"""typeInfo(RouteSeedlink self) -> RTTI"""
        return _datamodel.RouteSeedlink_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> RouteSeedlink
        Cast(Seiscomp::Core::BaseObjectPtr o) -> RouteSeedlink
        """
        return _datamodel.RouteSeedlink_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> RouteSeedlink
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RouteSeedlink
        """
        return _datamodel.RouteSeedlink_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(RouteSeedlink self, GenericArchive ar)"""
        return _datamodel.RouteSeedlink_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.RouteSeedlink_Meta()

    def meta(self):
        r"""meta(RouteSeedlink self) -> MetaObject"""
        return _datamodel.RouteSeedlink_meta(self)

    def __init__(self, *args):
        r"""
        __init__(RouteSeedlink self) -> RouteSeedlink
        __init__(RouteSeedlink self, RouteSeedlink other) -> RouteSeedlink
        """
        _datamodel.RouteSeedlink_swiginit(self, _datamodel.new_RouteSeedlink(*args))
    __swig_destroy__ = _datamodel.delete_RouteSeedlink

    def __eq__(self, other):
        r"""__eq__(RouteSeedlink self, RouteSeedlink other) -> bool"""
        return _datamodel.RouteSeedlink___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(RouteSeedlink self, RouteSeedlink other) -> bool"""
        return _datamodel.RouteSeedlink___ne__(self, other)

    def equal(self, other):
        r"""equal(RouteSeedlink self, RouteSeedlink other) -> bool"""
        return _datamodel.RouteSeedlink_equal(self, other)

    def setAddress(self, address):
        r"""setAddress(RouteSeedlink self, std::string const & address)"""
        return _datamodel.RouteSeedlink_setAddress(self, address)

    def address(self):
        r"""address(RouteSeedlink self) -> std::string const &"""
        return _datamodel.RouteSeedlink_address(self)

    def setPriority(self, priority):
        r"""setPriority(RouteSeedlink self, Seiscomp::Core::Optional< int >::Impl const & priority)"""
        return _datamodel.RouteSeedlink_setPriority(self, priority)

    def priority(self):
        r"""priority(RouteSeedlink self) -> int"""
        return _datamodel.RouteSeedlink_priority(self)

    def index(self):
        r"""index(RouteSeedlink self) -> RouteSeedlinkIndex"""
        return _datamodel.RouteSeedlink_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(RouteSeedlink self, RouteSeedlink lhs) -> bool"""
        return _datamodel.RouteSeedlink_equalIndex(self, lhs)

    def route(self):
        r"""route(RouteSeedlink self) -> Route"""
        return _datamodel.RouteSeedlink_route(self)

    def assign(self, other):
        r"""assign(RouteSeedlink self, Object other) -> bool"""
        return _datamodel.RouteSeedlink_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(RouteSeedlink self, PublicObject parent) -> bool"""
        return _datamodel.RouteSeedlink_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(RouteSeedlink self, PublicObject parent) -> bool"""
        return _datamodel.RouteSeedlink_detachFrom(self, parent)

    def detach(self):
        r"""detach(RouteSeedlink self) -> bool"""
        return _datamodel.RouteSeedlink_detach(self)

    def clone(self):
        r"""clone(RouteSeedlink self) -> Object"""
        return _datamodel.RouteSeedlink_clone(self)

    def accept(self, visitor):
        r"""accept(RouteSeedlink self, Visitor visitor)"""
        return _datamodel.RouteSeedlink_accept(self, visitor)

# Register RouteSeedlink in _datamodel:
_datamodel.RouteSeedlink_swigregister(RouteSeedlink)

def RouteSeedlink_ClassName():
    r"""RouteSeedlink_ClassName() -> char const *"""
    return _datamodel.RouteSeedlink_ClassName()

def RouteSeedlink_TypeInfo():
    r"""RouteSeedlink_TypeInfo() -> RTTI"""
    return _datamodel.RouteSeedlink_TypeInfo()

def RouteSeedlink_Cast(*args):
    r"""
    RouteSeedlink_Cast(BaseObject o) -> RouteSeedlink
    RouteSeedlink_Cast(Seiscomp::Core::BaseObjectPtr o) -> RouteSeedlink
    """
    return _datamodel.RouteSeedlink_Cast(*args)

def RouteSeedlink_ConstCast(*args):
    r"""
    RouteSeedlink_ConstCast(BaseObject o) -> RouteSeedlink
    RouteSeedlink_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RouteSeedlink
    """
    return _datamodel.RouteSeedlink_ConstCast(*args)

def RouteSeedlink_Meta():
    r"""RouteSeedlink_Meta() -> MetaObject"""
    return _datamodel.RouteSeedlink_Meta()

class RouteIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::RouteIndex 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__(RouteIndex self) -> RouteIndex
        __init__(RouteIndex self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & streamCode) -> RouteIndex
        __init__(RouteIndex self, RouteIndex arg2) -> RouteIndex
        """
        _datamodel.RouteIndex_swiginit(self, _datamodel.new_RouteIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(RouteIndex self, RouteIndex arg2) -> bool"""
        return _datamodel.RouteIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(RouteIndex self, RouteIndex arg2) -> bool"""
        return _datamodel.RouteIndex___ne__(self, arg2)
    networkCode = property(_datamodel.RouteIndex_networkCode_get, _datamodel.RouteIndex_networkCode_set, doc=r"""networkCode : std::string""")
    stationCode = property(_datamodel.RouteIndex_stationCode_get, _datamodel.RouteIndex_stationCode_set, doc=r"""stationCode : std::string""")
    locationCode = property(_datamodel.RouteIndex_locationCode_get, _datamodel.RouteIndex_locationCode_set, doc=r"""locationCode : std::string""")
    streamCode = property(_datamodel.RouteIndex_streamCode_get, _datamodel.RouteIndex_streamCode_set, doc=r"""streamCode : std::string""")
    __swig_destroy__ = _datamodel.delete_RouteIndex

# Register RouteIndex in _datamodel:
_datamodel.RouteIndex_swigregister(RouteIndex)

class Route(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Route 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 _datamodel.Route_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Route_TypeInfo()

    def className(self):
        r"""className(Route self) -> char const *"""
        return _datamodel.Route_className(self)

    def typeInfo(self):
        r"""typeInfo(Route self) -> RTTI"""
        return _datamodel.Route_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Route
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Route
        """
        return _datamodel.Route_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Route
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Route
        """
        return _datamodel.Route_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Route self, GenericArchive ar)"""
        return _datamodel.Route_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Route_Meta()

    def meta(self):
        r"""meta(Route self) -> MetaObject"""
        return _datamodel.Route_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Route self, Route other) -> Route
        __init__(Route self, std::string const & publicID) -> Route
        """
        _datamodel.Route_swiginit(self, _datamodel.new_Route(*args))
    __swig_destroy__ = _datamodel.delete_Route

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Route
        Create(std::string const & publicID) -> Route
        """
        return _datamodel.Route_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Route"""
        return _datamodel.Route_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Route self, Route other) -> bool"""
        return _datamodel.Route___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Route self, Route other) -> bool"""
        return _datamodel.Route___ne__(self, other)

    def equal(self, other):
        r"""equal(Route self, Route other) -> bool"""
        return _datamodel.Route_equal(self, other)

    def setNetworkCode(self, networkCode):
        r"""setNetworkCode(Route self, std::string const & networkCode)"""
        return _datamodel.Route_setNetworkCode(self, networkCode)

    def networkCode(self):
        r"""networkCode(Route self) -> std::string const &"""
        return _datamodel.Route_networkCode(self)

    def setStationCode(self, stationCode):
        r"""setStationCode(Route self, std::string const & stationCode)"""
        return _datamodel.Route_setStationCode(self, stationCode)

    def stationCode(self):
        r"""stationCode(Route self) -> std::string const &"""
        return _datamodel.Route_stationCode(self)

    def setLocationCode(self, locationCode):
        r"""setLocationCode(Route self, std::string const & locationCode)"""
        return _datamodel.Route_setLocationCode(self, locationCode)

    def locationCode(self):
        r"""locationCode(Route self) -> std::string const &"""
        return _datamodel.Route_locationCode(self)

    def setStreamCode(self, streamCode):
        r"""setStreamCode(Route self, std::string const & streamCode)"""
        return _datamodel.Route_setStreamCode(self, streamCode)

    def streamCode(self):
        r"""streamCode(Route self) -> std::string const &"""
        return _datamodel.Route_streamCode(self)

    def index(self):
        r"""index(Route self) -> RouteIndex"""
        return _datamodel.Route_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Route self, Route lhs) -> bool"""
        return _datamodel.Route_equalIndex(self, lhs)

    def add(self, *args):
        r"""
        add(Route self, RouteArclink obj) -> bool
        add(Route self, RouteSeedlink obj) -> bool
        """
        return _datamodel.Route_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Route self, RouteArclink obj) -> bool
        remove(Route self, RouteSeedlink obj) -> bool
        """
        return _datamodel.Route_remove(self, *args)

    def removeRouteArclink(self, *args):
        r"""
        removeRouteArclink(Route self, size_t i) -> bool
        removeRouteArclink(Route self, RouteArclinkIndex i) -> bool
        """
        return _datamodel.Route_removeRouteArclink(self, *args)

    def removeRouteSeedlink(self, *args):
        r"""
        removeRouteSeedlink(Route self, size_t i) -> bool
        removeRouteSeedlink(Route self, RouteSeedlinkIndex i) -> bool
        """
        return _datamodel.Route_removeRouteSeedlink(self, *args)

    def routeArclinkCount(self):
        r"""routeArclinkCount(Route self) -> size_t"""
        return _datamodel.Route_routeArclinkCount(self)

    def routeSeedlinkCount(self):
        r"""routeSeedlinkCount(Route self) -> size_t"""
        return _datamodel.Route_routeSeedlinkCount(self)

    def routeArclink(self, *args):
        r"""
        routeArclink(Route self, size_t i) -> RouteArclink
        routeArclink(Route self, RouteArclinkIndex i) -> RouteArclink
        """
        return _datamodel.Route_routeArclink(self, *args)

    def routeSeedlink(self, *args):
        r"""
        routeSeedlink(Route self, size_t i) -> RouteSeedlink
        routeSeedlink(Route self, RouteSeedlinkIndex i) -> RouteSeedlink
        """
        return _datamodel.Route_routeSeedlink(self, *args)

    def routing(self):
        r"""routing(Route self) -> Routing"""
        return _datamodel.Route_routing(self)

    def assign(self, other):
        r"""assign(Route self, Object other) -> bool"""
        return _datamodel.Route_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Route self, PublicObject parent) -> bool"""
        return _datamodel.Route_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Route self, PublicObject parent) -> bool"""
        return _datamodel.Route_detachFrom(self, parent)

    def detach(self):
        r"""detach(Route self) -> bool"""
        return _datamodel.Route_detach(self)

    def clone(self):
        r"""clone(Route self) -> Object"""
        return _datamodel.Route_clone(self)

    def updateChild(self, child):
        r"""updateChild(Route self, Object child) -> bool"""
        return _datamodel.Route_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Route self, Visitor visitor)"""
        return _datamodel.Route_accept(self, visitor)

# Register Route in _datamodel:
_datamodel.Route_swigregister(Route)

def Route_ClassName():
    r"""Route_ClassName() -> char const *"""
    return _datamodel.Route_ClassName()

def Route_TypeInfo():
    r"""Route_TypeInfo() -> RTTI"""
    return _datamodel.Route_TypeInfo()

def Route_Cast(*args):
    r"""
    Route_Cast(BaseObject o) -> Route
    Route_Cast(Seiscomp::Core::BaseObjectPtr o) -> Route
    """
    return _datamodel.Route_Cast(*args)

def Route_ConstCast(*args):
    r"""
    Route_ConstCast(BaseObject o) -> Route
    Route_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Route
    """
    return _datamodel.Route_ConstCast(*args)

def Route_Meta():
    r"""Route_Meta() -> MetaObject"""
    return _datamodel.Route_Meta()

def Route_Create(*args):
    r"""
    Route_Create() -> Route
    Route_Create(std::string const & publicID) -> Route
    """
    return _datamodel.Route_Create(*args)

def Route_Find(publicID):
    r"""Route_Find(std::string const & publicID) -> Route"""
    return _datamodel.Route_Find(publicID)

class AccessIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::AccessIndex 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__(AccessIndex self) -> AccessIndex
        __init__(AccessIndex self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & streamCode, std::string const & user, Time start) -> AccessIndex
        __init__(AccessIndex self, AccessIndex arg2) -> AccessIndex
        """
        _datamodel.AccessIndex_swiginit(self, _datamodel.new_AccessIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(AccessIndex self, AccessIndex arg2) -> bool"""
        return _datamodel.AccessIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(AccessIndex self, AccessIndex arg2) -> bool"""
        return _datamodel.AccessIndex___ne__(self, arg2)
    networkCode = property(_datamodel.AccessIndex_networkCode_get, _datamodel.AccessIndex_networkCode_set, doc=r"""networkCode : std::string""")
    stationCode = property(_datamodel.AccessIndex_stationCode_get, _datamodel.AccessIndex_stationCode_set, doc=r"""stationCode : std::string""")
    locationCode = property(_datamodel.AccessIndex_locationCode_get, _datamodel.AccessIndex_locationCode_set, doc=r"""locationCode : std::string""")
    streamCode = property(_datamodel.AccessIndex_streamCode_get, _datamodel.AccessIndex_streamCode_set, doc=r"""streamCode : std::string""")
    user = property(_datamodel.AccessIndex_user_get, _datamodel.AccessIndex_user_set, doc=r"""user : std::string""")
    start = property(_datamodel.AccessIndex_start_get, _datamodel.AccessIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_AccessIndex

# Register AccessIndex in _datamodel:
_datamodel.AccessIndex_swigregister(AccessIndex)

class Access(Object):
    r"""Proxy of C++ Seiscomp::DataModel::Access 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 _datamodel.Access_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Access_TypeInfo()

    def className(self):
        r"""className(Access self) -> char const *"""
        return _datamodel.Access_className(self)

    def typeInfo(self):
        r"""typeInfo(Access self) -> RTTI"""
        return _datamodel.Access_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Access
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Access
        """
        return _datamodel.Access_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Access
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Access
        """
        return _datamodel.Access_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Access self, GenericArchive ar)"""
        return _datamodel.Access_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Access_Meta()

    def meta(self):
        r"""meta(Access self) -> MetaObject"""
        return _datamodel.Access_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Access self) -> Access
        __init__(Access self, Access other) -> Access
        """
        _datamodel.Access_swiginit(self, _datamodel.new_Access(*args))
    __swig_destroy__ = _datamodel.delete_Access

    def __eq__(self, other):
        r"""__eq__(Access self, Access other) -> bool"""
        return _datamodel.Access___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Access self, Access other) -> bool"""
        return _datamodel.Access___ne__(self, other)

    def equal(self, other):
        r"""equal(Access self, Access other) -> bool"""
        return _datamodel.Access_equal(self, other)

    def setNetworkCode(self, networkCode):
        r"""setNetworkCode(Access self, std::string const & networkCode)"""
        return _datamodel.Access_setNetworkCode(self, networkCode)

    def networkCode(self):
        r"""networkCode(Access self) -> std::string const &"""
        return _datamodel.Access_networkCode(self)

    def setStationCode(self, stationCode):
        r"""setStationCode(Access self, std::string const & stationCode)"""
        return _datamodel.Access_setStationCode(self, stationCode)

    def stationCode(self):
        r"""stationCode(Access self) -> std::string const &"""
        return _datamodel.Access_stationCode(self)

    def setLocationCode(self, locationCode):
        r"""setLocationCode(Access self, std::string const & locationCode)"""
        return _datamodel.Access_setLocationCode(self, locationCode)

    def locationCode(self):
        r"""locationCode(Access self) -> std::string const &"""
        return _datamodel.Access_locationCode(self)

    def setStreamCode(self, streamCode):
        r"""setStreamCode(Access self, std::string const & streamCode)"""
        return _datamodel.Access_setStreamCode(self, streamCode)

    def streamCode(self):
        r"""streamCode(Access self) -> std::string const &"""
        return _datamodel.Access_streamCode(self)

    def setUser(self, user):
        r"""setUser(Access self, std::string const & user)"""
        return _datamodel.Access_setUser(self, user)

    def user(self):
        r"""user(Access self) -> std::string const &"""
        return _datamodel.Access_user(self)

    def setStart(self, start):
        r"""setStart(Access self, Time start)"""
        return _datamodel.Access_setStart(self, start)

    def start(self):
        r"""start(Access self) -> Time"""
        return _datamodel.Access_start(self)

    def setEnd(self, end):
        r"""setEnd(Access self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
        return _datamodel.Access_setEnd(self, end)

    def end(self):
        r"""end(Access self) -> Time"""
        return _datamodel.Access_end(self)

    def index(self):
        r"""index(Access self) -> AccessIndex"""
        return _datamodel.Access_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(Access self, Access lhs) -> bool"""
        return _datamodel.Access_equalIndex(self, lhs)

    def routing(self):
        r"""routing(Access self) -> Routing"""
        return _datamodel.Access_routing(self)

    def assign(self, other):
        r"""assign(Access self, Object other) -> bool"""
        return _datamodel.Access_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Access self, PublicObject parent) -> bool"""
        return _datamodel.Access_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Access self, PublicObject parent) -> bool"""
        return _datamodel.Access_detachFrom(self, parent)

    def detach(self):
        r"""detach(Access self) -> bool"""
        return _datamodel.Access_detach(self)

    def clone(self):
        r"""clone(Access self) -> Object"""
        return _datamodel.Access_clone(self)

    def accept(self, visitor):
        r"""accept(Access self, Visitor visitor)"""
        return _datamodel.Access_accept(self, visitor)

# Register Access in _datamodel:
_datamodel.Access_swigregister(Access)

def Access_ClassName():
    r"""Access_ClassName() -> char const *"""
    return _datamodel.Access_ClassName()

def Access_TypeInfo():
    r"""Access_TypeInfo() -> RTTI"""
    return _datamodel.Access_TypeInfo()

def Access_Cast(*args):
    r"""
    Access_Cast(BaseObject o) -> Access
    Access_Cast(Seiscomp::Core::BaseObjectPtr o) -> Access
    """
    return _datamodel.Access_Cast(*args)

def Access_ConstCast(*args):
    r"""
    Access_ConstCast(BaseObject o) -> Access
    Access_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Access
    """
    return _datamodel.Access_ConstCast(*args)

def Access_Meta():
    r"""Access_Meta() -> MetaObject"""
    return _datamodel.Access_Meta()

class Routing(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Routing 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 _datamodel.Routing_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Routing_TypeInfo()

    def className(self):
        r"""className(Routing self) -> char const *"""
        return _datamodel.Routing_className(self)

    def typeInfo(self):
        r"""typeInfo(Routing self) -> RTTI"""
        return _datamodel.Routing_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Routing
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Routing
        """
        return _datamodel.Routing_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Routing
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Routing
        """
        return _datamodel.Routing_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Routing self, GenericArchive ar)"""
        return _datamodel.Routing_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Routing_Meta()

    def meta(self):
        r"""meta(Routing self) -> MetaObject"""
        return _datamodel.Routing_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Routing self) -> Routing
        __init__(Routing self, Routing other) -> Routing
        """
        _datamodel.Routing_swiginit(self, _datamodel.new_Routing(*args))
    __swig_destroy__ = _datamodel.delete_Routing

    def __eq__(self, other):
        r"""__eq__(Routing self, Routing other) -> bool"""
        return _datamodel.Routing___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Routing self, Routing other) -> bool"""
        return _datamodel.Routing___ne__(self, other)

    def equal(self, other):
        r"""equal(Routing self, Routing other) -> bool"""
        return _datamodel.Routing_equal(self, other)

    def add(self, *args):
        r"""
        add(Routing self, Route obj) -> bool
        add(Routing self, Access obj) -> bool
        """
        return _datamodel.Routing_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Routing self, Route obj) -> bool
        remove(Routing self, Access obj) -> bool
        """
        return _datamodel.Routing_remove(self, *args)

    def removeRoute(self, *args):
        r"""
        removeRoute(Routing self, size_t i) -> bool
        removeRoute(Routing self, RouteIndex i) -> bool
        """
        return _datamodel.Routing_removeRoute(self, *args)

    def removeAccess(self, *args):
        r"""
        removeAccess(Routing self, size_t i) -> bool
        removeAccess(Routing self, AccessIndex i) -> bool
        """
        return _datamodel.Routing_removeAccess(self, *args)

    def routeCount(self):
        r"""routeCount(Routing self) -> size_t"""
        return _datamodel.Routing_routeCount(self)

    def accessCount(self):
        r"""accessCount(Routing self) -> size_t"""
        return _datamodel.Routing_accessCount(self)

    def route(self, *args):
        r"""
        route(Routing self, size_t i) -> Route
        route(Routing self, RouteIndex i) -> Route
        """
        return _datamodel.Routing_route(self, *args)

    def access(self, *args):
        r"""
        access(Routing self, size_t i) -> Access
        access(Routing self, AccessIndex i) -> Access
        """
        return _datamodel.Routing_access(self, *args)

    def findRoute(self, publicID):
        r"""findRoute(Routing self, std::string const & publicID) -> Route"""
        return _datamodel.Routing_findRoute(self, publicID)

    def assign(self, other):
        r"""assign(Routing self, Object other) -> bool"""
        return _datamodel.Routing_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Routing self, PublicObject parent) -> bool"""
        return _datamodel.Routing_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Routing self, PublicObject parent) -> bool"""
        return _datamodel.Routing_detachFrom(self, parent)

    def detach(self):
        r"""detach(Routing self) -> bool"""
        return _datamodel.Routing_detach(self)

    def clone(self):
        r"""clone(Routing self) -> Object"""
        return _datamodel.Routing_clone(self)

    def updateChild(self, child):
        r"""updateChild(Routing self, Object child) -> bool"""
        return _datamodel.Routing_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Routing self, Visitor visitor)"""
        return _datamodel.Routing_accept(self, visitor)

# Register Routing in _datamodel:
_datamodel.Routing_swigregister(Routing)

def Routing_ClassName():
    r"""Routing_ClassName() -> char const *"""
    return _datamodel.Routing_ClassName()

def Routing_TypeInfo():
    r"""Routing_TypeInfo() -> RTTI"""
    return _datamodel.Routing_TypeInfo()

def Routing_Cast(*args):
    r"""
    Routing_Cast(BaseObject o) -> Routing
    Routing_Cast(Seiscomp::Core::BaseObjectPtr o) -> Routing
    """
    return _datamodel.Routing_Cast(*args)

def Routing_ConstCast(*args):
    r"""
    Routing_ConstCast(BaseObject o) -> Routing
    Routing_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Routing
    """
    return _datamodel.Routing_ConstCast(*args)

def Routing_Meta():
    r"""Routing_Meta() -> MetaObject"""
    return _datamodel.Routing_Meta()

class JournalEntry(Object):
    r"""Proxy of C++ Seiscomp::DataModel::JournalEntry 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 _datamodel.JournalEntry_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.JournalEntry_TypeInfo()

    def className(self):
        r"""className(JournalEntry self) -> char const *"""
        return _datamodel.JournalEntry_className(self)

    def typeInfo(self):
        r"""typeInfo(JournalEntry self) -> RTTI"""
        return _datamodel.JournalEntry_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> JournalEntry
        Cast(Seiscomp::Core::BaseObjectPtr o) -> JournalEntry
        """
        return _datamodel.JournalEntry_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> JournalEntry
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> JournalEntry
        """
        return _datamodel.JournalEntry_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(JournalEntry self, GenericArchive ar)"""
        return _datamodel.JournalEntry_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.JournalEntry_Meta()

    def meta(self):
        r"""meta(JournalEntry self) -> MetaObject"""
        return _datamodel.JournalEntry_meta(self)

    def __init__(self, *args):
        r"""
        __init__(JournalEntry self) -> JournalEntry
        __init__(JournalEntry self, JournalEntry other) -> JournalEntry
        """
        _datamodel.JournalEntry_swiginit(self, _datamodel.new_JournalEntry(*args))
    __swig_destroy__ = _datamodel.delete_JournalEntry

    def __eq__(self, other):
        r"""__eq__(JournalEntry self, JournalEntry other) -> bool"""
        return _datamodel.JournalEntry___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(JournalEntry self, JournalEntry other) -> bool"""
        return _datamodel.JournalEntry___ne__(self, other)

    def equal(self, other):
        r"""equal(JournalEntry self, JournalEntry other) -> bool"""
        return _datamodel.JournalEntry_equal(self, other)

    def setCreated(self, created):
        r"""setCreated(JournalEntry self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & created)"""
        return _datamodel.JournalEntry_setCreated(self, created)

    def created(self):
        r"""created(JournalEntry self) -> Time"""
        return _datamodel.JournalEntry_created(self)

    def setObjectID(self, objectID):
        r"""setObjectID(JournalEntry self, std::string const & objectID)"""
        return _datamodel.JournalEntry_setObjectID(self, objectID)

    def objectID(self):
        r"""objectID(JournalEntry self) -> std::string const &"""
        return _datamodel.JournalEntry_objectID(self)

    def setSender(self, sender):
        r"""setSender(JournalEntry self, std::string const & sender)"""
        return _datamodel.JournalEntry_setSender(self, sender)

    def sender(self):
        r"""sender(JournalEntry self) -> std::string const &"""
        return _datamodel.JournalEntry_sender(self)

    def setAction(self, action):
        r"""setAction(JournalEntry self, std::string const & action)"""
        return _datamodel.JournalEntry_setAction(self, action)

    def action(self):
        r"""action(JournalEntry self) -> std::string const &"""
        return _datamodel.JournalEntry_action(self)

    def setParameters(self, parameters):
        r"""setParameters(JournalEntry self, std::string const & parameters)"""
        return _datamodel.JournalEntry_setParameters(self, parameters)

    def parameters(self):
        r"""parameters(JournalEntry self) -> std::string const &"""
        return _datamodel.JournalEntry_parameters(self)

    def journaling(self):
        r"""journaling(JournalEntry self) -> Journaling"""
        return _datamodel.JournalEntry_journaling(self)

    def assign(self, other):
        r"""assign(JournalEntry self, Object other) -> bool"""
        return _datamodel.JournalEntry_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(JournalEntry self, PublicObject parent) -> bool"""
        return _datamodel.JournalEntry_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(JournalEntry self, PublicObject parent) -> bool"""
        return _datamodel.JournalEntry_detachFrom(self, parent)

    def detach(self):
        r"""detach(JournalEntry self) -> bool"""
        return _datamodel.JournalEntry_detach(self)

    def clone(self):
        r"""clone(JournalEntry self) -> Object"""
        return _datamodel.JournalEntry_clone(self)

    def accept(self, visitor):
        r"""accept(JournalEntry self, Visitor visitor)"""
        return _datamodel.JournalEntry_accept(self, visitor)

# Register JournalEntry in _datamodel:
_datamodel.JournalEntry_swigregister(JournalEntry)

def JournalEntry_ClassName():
    r"""JournalEntry_ClassName() -> char const *"""
    return _datamodel.JournalEntry_ClassName()

def JournalEntry_TypeInfo():
    r"""JournalEntry_TypeInfo() -> RTTI"""
    return _datamodel.JournalEntry_TypeInfo()

def JournalEntry_Cast(*args):
    r"""
    JournalEntry_Cast(BaseObject o) -> JournalEntry
    JournalEntry_Cast(Seiscomp::Core::BaseObjectPtr o) -> JournalEntry
    """
    return _datamodel.JournalEntry_Cast(*args)

def JournalEntry_ConstCast(*args):
    r"""
    JournalEntry_ConstCast(BaseObject o) -> JournalEntry
    JournalEntry_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> JournalEntry
    """
    return _datamodel.JournalEntry_ConstCast(*args)

def JournalEntry_Meta():
    r"""JournalEntry_Meta() -> MetaObject"""
    return _datamodel.JournalEntry_Meta()

class Journaling(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::Journaling 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 _datamodel.Journaling_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.Journaling_TypeInfo()

    def className(self):
        r"""className(Journaling self) -> char const *"""
        return _datamodel.Journaling_className(self)

    def typeInfo(self):
        r"""typeInfo(Journaling self) -> RTTI"""
        return _datamodel.Journaling_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Journaling
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Journaling
        """
        return _datamodel.Journaling_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Journaling
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Journaling
        """
        return _datamodel.Journaling_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Journaling self, GenericArchive ar)"""
        return _datamodel.Journaling_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.Journaling_Meta()

    def meta(self):
        r"""meta(Journaling self) -> MetaObject"""
        return _datamodel.Journaling_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Journaling self) -> Journaling
        __init__(Journaling self, Journaling other) -> Journaling
        """
        _datamodel.Journaling_swiginit(self, _datamodel.new_Journaling(*args))
    __swig_destroy__ = _datamodel.delete_Journaling

    def __eq__(self, other):
        r"""__eq__(Journaling self, Journaling other) -> bool"""
        return _datamodel.Journaling___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Journaling self, Journaling other) -> bool"""
        return _datamodel.Journaling___ne__(self, other)

    def equal(self, other):
        r"""equal(Journaling self, Journaling other) -> bool"""
        return _datamodel.Journaling_equal(self, other)

    def add(self, obj):
        r"""add(Journaling self, JournalEntry obj) -> bool"""
        return _datamodel.Journaling_add(self, obj)

    def remove(self, obj):
        r"""remove(Journaling self, JournalEntry obj) -> bool"""
        return _datamodel.Journaling_remove(self, obj)

    def removeJournalEntry(self, i):
        r"""removeJournalEntry(Journaling self, size_t i) -> bool"""
        return _datamodel.Journaling_removeJournalEntry(self, i)

    def journalEntryCount(self):
        r"""journalEntryCount(Journaling self) -> size_t"""
        return _datamodel.Journaling_journalEntryCount(self)

    def journalEntry(self, i):
        r"""journalEntry(Journaling self, size_t i) -> JournalEntry"""
        return _datamodel.Journaling_journalEntry(self, i)

    def findJournalEntry(self, journalEntry):
        r"""findJournalEntry(Journaling self, JournalEntry journalEntry) -> JournalEntry"""
        return _datamodel.Journaling_findJournalEntry(self, journalEntry)

    def assign(self, other):
        r"""assign(Journaling self, Object other) -> bool"""
        return _datamodel.Journaling_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Journaling self, PublicObject parent) -> bool"""
        return _datamodel.Journaling_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Journaling self, PublicObject parent) -> bool"""
        return _datamodel.Journaling_detachFrom(self, parent)

    def detach(self):
        r"""detach(Journaling self) -> bool"""
        return _datamodel.Journaling_detach(self)

    def clone(self):
        r"""clone(Journaling self) -> Object"""
        return _datamodel.Journaling_clone(self)

    def updateChild(self, child):
        r"""updateChild(Journaling self, Object child) -> bool"""
        return _datamodel.Journaling_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(Journaling self, Visitor visitor)"""
        return _datamodel.Journaling_accept(self, visitor)

# Register Journaling in _datamodel:
_datamodel.Journaling_swigregister(Journaling)

def Journaling_ClassName():
    r"""Journaling_ClassName() -> char const *"""
    return _datamodel.Journaling_ClassName()

def Journaling_TypeInfo():
    r"""Journaling_TypeInfo() -> RTTI"""
    return _datamodel.Journaling_TypeInfo()

def Journaling_Cast(*args):
    r"""
    Journaling_Cast(BaseObject o) -> Journaling
    Journaling_Cast(Seiscomp::Core::BaseObjectPtr o) -> Journaling
    """
    return _datamodel.Journaling_Cast(*args)

def Journaling_ConstCast(*args):
    r"""
    Journaling_ConstCast(BaseObject o) -> Journaling
    Journaling_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Journaling
    """
    return _datamodel.Journaling_ConstCast(*args)

def Journaling_Meta():
    r"""Journaling_Meta() -> MetaObject"""
    return _datamodel.Journaling_Meta()

class ArclinkUserIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkUserIndex 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__(ArclinkUserIndex self) -> ArclinkUserIndex
        __init__(ArclinkUserIndex self, std::string const & name, std::string const & email) -> ArclinkUserIndex
        __init__(ArclinkUserIndex self, ArclinkUserIndex arg2) -> ArclinkUserIndex
        """
        _datamodel.ArclinkUserIndex_swiginit(self, _datamodel.new_ArclinkUserIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ArclinkUserIndex self, ArclinkUserIndex arg2) -> bool"""
        return _datamodel.ArclinkUserIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ArclinkUserIndex self, ArclinkUserIndex arg2) -> bool"""
        return _datamodel.ArclinkUserIndex___ne__(self, arg2)
    name = property(_datamodel.ArclinkUserIndex_name_get, _datamodel.ArclinkUserIndex_name_set, doc=r"""name : std::string""")
    email = property(_datamodel.ArclinkUserIndex_email_get, _datamodel.ArclinkUserIndex_email_set, doc=r"""email : std::string""")
    __swig_destroy__ = _datamodel.delete_ArclinkUserIndex

# Register ArclinkUserIndex in _datamodel:
_datamodel.ArclinkUserIndex_swigregister(ArclinkUserIndex)

class ArclinkUser(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkUser 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 _datamodel.ArclinkUser_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ArclinkUser_TypeInfo()

    def className(self):
        r"""className(ArclinkUser self) -> char const *"""
        return _datamodel.ArclinkUser_className(self)

    def typeInfo(self):
        r"""typeInfo(ArclinkUser self) -> RTTI"""
        return _datamodel.ArclinkUser_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArclinkUser
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkUser
        """
        return _datamodel.ArclinkUser_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArclinkUser
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkUser
        """
        return _datamodel.ArclinkUser_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ArclinkUser self, GenericArchive ar)"""
        return _datamodel.ArclinkUser_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ArclinkUser_Meta()

    def meta(self):
        r"""meta(ArclinkUser self) -> MetaObject"""
        return _datamodel.ArclinkUser_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ArclinkUser self, ArclinkUser other) -> ArclinkUser
        __init__(ArclinkUser self, std::string const & publicID) -> ArclinkUser
        """
        _datamodel.ArclinkUser_swiginit(self, _datamodel.new_ArclinkUser(*args))
    __swig_destroy__ = _datamodel.delete_ArclinkUser

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ArclinkUser
        Create(std::string const & publicID) -> ArclinkUser
        """
        return _datamodel.ArclinkUser_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ArclinkUser"""
        return _datamodel.ArclinkUser_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ArclinkUser self, ArclinkUser other) -> bool"""
        return _datamodel.ArclinkUser___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ArclinkUser self, ArclinkUser other) -> bool"""
        return _datamodel.ArclinkUser___ne__(self, other)

    def equal(self, other):
        r"""equal(ArclinkUser self, ArclinkUser other) -> bool"""
        return _datamodel.ArclinkUser_equal(self, other)

    def setName(self, name):
        r"""setName(ArclinkUser self, std::string const & name)"""
        return _datamodel.ArclinkUser_setName(self, name)

    def name(self):
        r"""name(ArclinkUser self) -> std::string const &"""
        return _datamodel.ArclinkUser_name(self)

    def setEmail(self, email):
        r"""setEmail(ArclinkUser self, std::string const & email)"""
        return _datamodel.ArclinkUser_setEmail(self, email)

    def email(self):
        r"""email(ArclinkUser self) -> std::string const &"""
        return _datamodel.ArclinkUser_email(self)

    def setPassword(self, password):
        r"""setPassword(ArclinkUser self, std::string const & password)"""
        return _datamodel.ArclinkUser_setPassword(self, password)

    def password(self):
        r"""password(ArclinkUser self) -> std::string const &"""
        return _datamodel.ArclinkUser_password(self)

    def index(self):
        r"""index(ArclinkUser self) -> ArclinkUserIndex"""
        return _datamodel.ArclinkUser_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ArclinkUser self, ArclinkUser lhs) -> bool"""
        return _datamodel.ArclinkUser_equalIndex(self, lhs)

    def arclinkLog(self):
        r"""arclinkLog(ArclinkUser self) -> ArclinkLog"""
        return _datamodel.ArclinkUser_arclinkLog(self)

    def assign(self, other):
        r"""assign(ArclinkUser self, Object other) -> bool"""
        return _datamodel.ArclinkUser_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ArclinkUser self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkUser_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ArclinkUser self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkUser_detachFrom(self, parent)

    def detach(self):
        r"""detach(ArclinkUser self) -> bool"""
        return _datamodel.ArclinkUser_detach(self)

    def clone(self):
        r"""clone(ArclinkUser self) -> Object"""
        return _datamodel.ArclinkUser_clone(self)

    def updateChild(self, child):
        r"""updateChild(ArclinkUser self, Object child) -> bool"""
        return _datamodel.ArclinkUser_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ArclinkUser self, Visitor visitor)"""
        return _datamodel.ArclinkUser_accept(self, visitor)

# Register ArclinkUser in _datamodel:
_datamodel.ArclinkUser_swigregister(ArclinkUser)

def ArclinkUser_ClassName():
    r"""ArclinkUser_ClassName() -> char const *"""
    return _datamodel.ArclinkUser_ClassName()

def ArclinkUser_TypeInfo():
    r"""ArclinkUser_TypeInfo() -> RTTI"""
    return _datamodel.ArclinkUser_TypeInfo()

def ArclinkUser_Cast(*args):
    r"""
    ArclinkUser_Cast(BaseObject o) -> ArclinkUser
    ArclinkUser_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkUser
    """
    return _datamodel.ArclinkUser_Cast(*args)

def ArclinkUser_ConstCast(*args):
    r"""
    ArclinkUser_ConstCast(BaseObject o) -> ArclinkUser
    ArclinkUser_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkUser
    """
    return _datamodel.ArclinkUser_ConstCast(*args)

def ArclinkUser_Meta():
    r"""ArclinkUser_Meta() -> MetaObject"""
    return _datamodel.ArclinkUser_Meta()

def ArclinkUser_Create(*args):
    r"""
    ArclinkUser_Create() -> ArclinkUser
    ArclinkUser_Create(std::string const & publicID) -> ArclinkUser
    """
    return _datamodel.ArclinkUser_Create(*args)

def ArclinkUser_Find(publicID):
    r"""ArclinkUser_Find(std::string const & publicID) -> ArclinkUser"""
    return _datamodel.ArclinkUser_Find(publicID)

class ArclinkStatusLineIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkStatusLineIndex 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__(ArclinkStatusLineIndex self) -> ArclinkStatusLineIndex
        __init__(ArclinkStatusLineIndex self, std::string const & volumeID, std::string const & type, std::string const & status) -> ArclinkStatusLineIndex
        __init__(ArclinkStatusLineIndex self, ArclinkStatusLineIndex arg2) -> ArclinkStatusLineIndex
        """
        _datamodel.ArclinkStatusLineIndex_swiginit(self, _datamodel.new_ArclinkStatusLineIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ArclinkStatusLineIndex self, ArclinkStatusLineIndex arg2) -> bool"""
        return _datamodel.ArclinkStatusLineIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ArclinkStatusLineIndex self, ArclinkStatusLineIndex arg2) -> bool"""
        return _datamodel.ArclinkStatusLineIndex___ne__(self, arg2)
    volumeID = property(_datamodel.ArclinkStatusLineIndex_volumeID_get, _datamodel.ArclinkStatusLineIndex_volumeID_set, doc=r"""volumeID : std::string""")
    type = property(_datamodel.ArclinkStatusLineIndex_type_get, _datamodel.ArclinkStatusLineIndex_type_set, doc=r"""type : std::string""")
    status = property(_datamodel.ArclinkStatusLineIndex_status_get, _datamodel.ArclinkStatusLineIndex_status_set, doc=r"""status : std::string""")
    __swig_destroy__ = _datamodel.delete_ArclinkStatusLineIndex

# Register ArclinkStatusLineIndex in _datamodel:
_datamodel.ArclinkStatusLineIndex_swigregister(ArclinkStatusLineIndex)

class ArclinkStatusLine(Object):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkStatusLine 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 _datamodel.ArclinkStatusLine_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ArclinkStatusLine_TypeInfo()

    def className(self):
        r"""className(ArclinkStatusLine self) -> char const *"""
        return _datamodel.ArclinkStatusLine_className(self)

    def typeInfo(self):
        r"""typeInfo(ArclinkStatusLine self) -> RTTI"""
        return _datamodel.ArclinkStatusLine_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArclinkStatusLine
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkStatusLine
        """
        return _datamodel.ArclinkStatusLine_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArclinkStatusLine
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkStatusLine
        """
        return _datamodel.ArclinkStatusLine_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ArclinkStatusLine self, GenericArchive ar)"""
        return _datamodel.ArclinkStatusLine_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ArclinkStatusLine_Meta()

    def meta(self):
        r"""meta(ArclinkStatusLine self) -> MetaObject"""
        return _datamodel.ArclinkStatusLine_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ArclinkStatusLine self) -> ArclinkStatusLine
        __init__(ArclinkStatusLine self, ArclinkStatusLine other) -> ArclinkStatusLine
        """
        _datamodel.ArclinkStatusLine_swiginit(self, _datamodel.new_ArclinkStatusLine(*args))
    __swig_destroy__ = _datamodel.delete_ArclinkStatusLine

    def __eq__(self, other):
        r"""__eq__(ArclinkStatusLine self, ArclinkStatusLine other) -> bool"""
        return _datamodel.ArclinkStatusLine___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ArclinkStatusLine self, ArclinkStatusLine other) -> bool"""
        return _datamodel.ArclinkStatusLine___ne__(self, other)

    def equal(self, other):
        r"""equal(ArclinkStatusLine self, ArclinkStatusLine other) -> bool"""
        return _datamodel.ArclinkStatusLine_equal(self, other)

    def setType(self, type):
        r"""setType(ArclinkStatusLine self, std::string const & type)"""
        return _datamodel.ArclinkStatusLine_setType(self, type)

    def type(self):
        r"""type(ArclinkStatusLine self) -> std::string const &"""
        return _datamodel.ArclinkStatusLine_type(self)

    def setStatus(self, status):
        r"""setStatus(ArclinkStatusLine self, std::string const & status)"""
        return _datamodel.ArclinkStatusLine_setStatus(self, status)

    def status(self):
        r"""status(ArclinkStatusLine self) -> std::string const &"""
        return _datamodel.ArclinkStatusLine_status(self)

    def setSize(self, size):
        r"""setSize(ArclinkStatusLine self, Seiscomp::Core::Optional< int >::Impl const & size)"""
        return _datamodel.ArclinkStatusLine_setSize(self, size)

    def size(self):
        r"""size(ArclinkStatusLine self) -> int"""
        return _datamodel.ArclinkStatusLine_size(self)

    def setMessage(self, message):
        r"""setMessage(ArclinkStatusLine self, std::string const & message)"""
        return _datamodel.ArclinkStatusLine_setMessage(self, message)

    def message(self):
        r"""message(ArclinkStatusLine self) -> std::string const &"""
        return _datamodel.ArclinkStatusLine_message(self)

    def setVolumeID(self, volumeID):
        r"""setVolumeID(ArclinkStatusLine self, std::string const & volumeID)"""
        return _datamodel.ArclinkStatusLine_setVolumeID(self, volumeID)

    def volumeID(self):
        r"""volumeID(ArclinkStatusLine self) -> std::string const &"""
        return _datamodel.ArclinkStatusLine_volumeID(self)

    def index(self):
        r"""index(ArclinkStatusLine self) -> ArclinkStatusLineIndex"""
        return _datamodel.ArclinkStatusLine_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ArclinkStatusLine self, ArclinkStatusLine lhs) -> bool"""
        return _datamodel.ArclinkStatusLine_equalIndex(self, lhs)

    def arclinkRequest(self):
        r"""arclinkRequest(ArclinkStatusLine self) -> ArclinkRequest"""
        return _datamodel.ArclinkStatusLine_arclinkRequest(self)

    def assign(self, other):
        r"""assign(ArclinkStatusLine self, Object other) -> bool"""
        return _datamodel.ArclinkStatusLine_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ArclinkStatusLine self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkStatusLine_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ArclinkStatusLine self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkStatusLine_detachFrom(self, parent)

    def detach(self):
        r"""detach(ArclinkStatusLine self) -> bool"""
        return _datamodel.ArclinkStatusLine_detach(self)

    def clone(self):
        r"""clone(ArclinkStatusLine self) -> Object"""
        return _datamodel.ArclinkStatusLine_clone(self)

    def accept(self, visitor):
        r"""accept(ArclinkStatusLine self, Visitor visitor)"""
        return _datamodel.ArclinkStatusLine_accept(self, visitor)

# Register ArclinkStatusLine in _datamodel:
_datamodel.ArclinkStatusLine_swigregister(ArclinkStatusLine)

def ArclinkStatusLine_ClassName():
    r"""ArclinkStatusLine_ClassName() -> char const *"""
    return _datamodel.ArclinkStatusLine_ClassName()

def ArclinkStatusLine_TypeInfo():
    r"""ArclinkStatusLine_TypeInfo() -> RTTI"""
    return _datamodel.ArclinkStatusLine_TypeInfo()

def ArclinkStatusLine_Cast(*args):
    r"""
    ArclinkStatusLine_Cast(BaseObject o) -> ArclinkStatusLine
    ArclinkStatusLine_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkStatusLine
    """
    return _datamodel.ArclinkStatusLine_Cast(*args)

def ArclinkStatusLine_ConstCast(*args):
    r"""
    ArclinkStatusLine_ConstCast(BaseObject o) -> ArclinkStatusLine
    ArclinkStatusLine_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkStatusLine
    """
    return _datamodel.ArclinkStatusLine_ConstCast(*args)

def ArclinkStatusLine_Meta():
    r"""ArclinkStatusLine_Meta() -> MetaObject"""
    return _datamodel.ArclinkStatusLine_Meta()

class ArclinkRequestLineIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequestLineIndex 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__(ArclinkRequestLineIndex self) -> ArclinkRequestLineIndex
        __init__(ArclinkRequestLineIndex self, Time start, Time end, WaveformStreamID streamID) -> ArclinkRequestLineIndex
        __init__(ArclinkRequestLineIndex self, ArclinkRequestLineIndex arg2) -> ArclinkRequestLineIndex
        """
        _datamodel.ArclinkRequestLineIndex_swiginit(self, _datamodel.new_ArclinkRequestLineIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ArclinkRequestLineIndex self, ArclinkRequestLineIndex arg2) -> bool"""
        return _datamodel.ArclinkRequestLineIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ArclinkRequestLineIndex self, ArclinkRequestLineIndex arg2) -> bool"""
        return _datamodel.ArclinkRequestLineIndex___ne__(self, arg2)
    start = property(_datamodel.ArclinkRequestLineIndex_start_get, _datamodel.ArclinkRequestLineIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    end = property(_datamodel.ArclinkRequestLineIndex_end_get, _datamodel.ArclinkRequestLineIndex_end_set, doc=r"""end : Seiscomp::Core::Time""")
    streamID = property(_datamodel.ArclinkRequestLineIndex_streamID_get, _datamodel.ArclinkRequestLineIndex_streamID_set, doc=r"""streamID : Seiscomp::DataModel::WaveformStreamID""")
    __swig_destroy__ = _datamodel.delete_ArclinkRequestLineIndex

# Register ArclinkRequestLineIndex in _datamodel:
_datamodel.ArclinkRequestLineIndex_swigregister(ArclinkRequestLineIndex)

class ArclinkRequestLine(Object):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequestLine 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 _datamodel.ArclinkRequestLine_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ArclinkRequestLine_TypeInfo()

    def className(self):
        r"""className(ArclinkRequestLine self) -> char const *"""
        return _datamodel.ArclinkRequestLine_className(self)

    def typeInfo(self):
        r"""typeInfo(ArclinkRequestLine self) -> RTTI"""
        return _datamodel.ArclinkRequestLine_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArclinkRequestLine
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequestLine
        """
        return _datamodel.ArclinkRequestLine_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArclinkRequestLine
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequestLine
        """
        return _datamodel.ArclinkRequestLine_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ArclinkRequestLine self, GenericArchive ar)"""
        return _datamodel.ArclinkRequestLine_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ArclinkRequestLine_Meta()

    def meta(self):
        r"""meta(ArclinkRequestLine self) -> MetaObject"""
        return _datamodel.ArclinkRequestLine_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ArclinkRequestLine self) -> ArclinkRequestLine
        __init__(ArclinkRequestLine self, ArclinkRequestLine other) -> ArclinkRequestLine
        """
        _datamodel.ArclinkRequestLine_swiginit(self, _datamodel.new_ArclinkRequestLine(*args))
    __swig_destroy__ = _datamodel.delete_ArclinkRequestLine

    def __eq__(self, other):
        r"""__eq__(ArclinkRequestLine self, ArclinkRequestLine other) -> bool"""
        return _datamodel.ArclinkRequestLine___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ArclinkRequestLine self, ArclinkRequestLine other) -> bool"""
        return _datamodel.ArclinkRequestLine___ne__(self, other)

    def equal(self, other):
        r"""equal(ArclinkRequestLine self, ArclinkRequestLine other) -> bool"""
        return _datamodel.ArclinkRequestLine_equal(self, other)

    def setStart(self, start):
        r"""setStart(ArclinkRequestLine self, Time start)"""
        return _datamodel.ArclinkRequestLine_setStart(self, start)

    def start(self):
        r"""start(ArclinkRequestLine self) -> Time"""
        return _datamodel.ArclinkRequestLine_start(self)

    def setEnd(self, end):
        r"""setEnd(ArclinkRequestLine self, Time end)"""
        return _datamodel.ArclinkRequestLine_setEnd(self, end)

    def end(self):
        r"""end(ArclinkRequestLine self) -> Time"""
        return _datamodel.ArclinkRequestLine_end(self)

    def setStreamID(self, streamID):
        r"""setStreamID(ArclinkRequestLine self, WaveformStreamID streamID)"""
        return _datamodel.ArclinkRequestLine_setStreamID(self, streamID)

    def streamID(self, *args):
        r"""
        streamID(ArclinkRequestLine self) -> WaveformStreamID
        streamID(ArclinkRequestLine self) -> WaveformStreamID
        """
        return _datamodel.ArclinkRequestLine_streamID(self, *args)

    def setRestricted(self, restricted):
        r"""setRestricted(ArclinkRequestLine self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
        return _datamodel.ArclinkRequestLine_setRestricted(self, restricted)

    def restricted(self):
        r"""restricted(ArclinkRequestLine self) -> bool"""
        return _datamodel.ArclinkRequestLine_restricted(self)

    def setShared(self, shared):
        r"""setShared(ArclinkRequestLine self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
        return _datamodel.ArclinkRequestLine_setShared(self, shared)

    def shared(self):
        r"""shared(ArclinkRequestLine self) -> bool"""
        return _datamodel.ArclinkRequestLine_shared(self)

    def setNetClass(self, netClass):
        r"""setNetClass(ArclinkRequestLine self, std::string const & netClass)"""
        return _datamodel.ArclinkRequestLine_setNetClass(self, netClass)

    def netClass(self):
        r"""netClass(ArclinkRequestLine self) -> std::string const &"""
        return _datamodel.ArclinkRequestLine_netClass(self)

    def setConstraints(self, constraints):
        r"""setConstraints(ArclinkRequestLine self, std::string const & constraints)"""
        return _datamodel.ArclinkRequestLine_setConstraints(self, constraints)

    def constraints(self):
        r"""constraints(ArclinkRequestLine self) -> std::string const &"""
        return _datamodel.ArclinkRequestLine_constraints(self)

    def setStatus(self, status):
        r"""setStatus(ArclinkRequestLine self, ArclinkStatusLine status)"""
        return _datamodel.ArclinkRequestLine_setStatus(self, status)

    def status(self, *args):
        r"""
        status(ArclinkRequestLine self) -> ArclinkStatusLine
        status(ArclinkRequestLine self) -> ArclinkStatusLine
        """
        return _datamodel.ArclinkRequestLine_status(self, *args)

    def index(self):
        r"""index(ArclinkRequestLine self) -> ArclinkRequestLineIndex"""
        return _datamodel.ArclinkRequestLine_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ArclinkRequestLine self, ArclinkRequestLine lhs) -> bool"""
        return _datamodel.ArclinkRequestLine_equalIndex(self, lhs)

    def arclinkRequest(self):
        r"""arclinkRequest(ArclinkRequestLine self) -> ArclinkRequest"""
        return _datamodel.ArclinkRequestLine_arclinkRequest(self)

    def assign(self, other):
        r"""assign(ArclinkRequestLine self, Object other) -> bool"""
        return _datamodel.ArclinkRequestLine_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ArclinkRequestLine self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkRequestLine_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ArclinkRequestLine self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkRequestLine_detachFrom(self, parent)

    def detach(self):
        r"""detach(ArclinkRequestLine self) -> bool"""
        return _datamodel.ArclinkRequestLine_detach(self)

    def clone(self):
        r"""clone(ArclinkRequestLine self) -> Object"""
        return _datamodel.ArclinkRequestLine_clone(self)

    def accept(self, visitor):
        r"""accept(ArclinkRequestLine self, Visitor visitor)"""
        return _datamodel.ArclinkRequestLine_accept(self, visitor)

# Register ArclinkRequestLine in _datamodel:
_datamodel.ArclinkRequestLine_swigregister(ArclinkRequestLine)

def ArclinkRequestLine_ClassName():
    r"""ArclinkRequestLine_ClassName() -> char const *"""
    return _datamodel.ArclinkRequestLine_ClassName()

def ArclinkRequestLine_TypeInfo():
    r"""ArclinkRequestLine_TypeInfo() -> RTTI"""
    return _datamodel.ArclinkRequestLine_TypeInfo()

def ArclinkRequestLine_Cast(*args):
    r"""
    ArclinkRequestLine_Cast(BaseObject o) -> ArclinkRequestLine
    ArclinkRequestLine_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequestLine
    """
    return _datamodel.ArclinkRequestLine_Cast(*args)

def ArclinkRequestLine_ConstCast(*args):
    r"""
    ArclinkRequestLine_ConstCast(BaseObject o) -> ArclinkRequestLine
    ArclinkRequestLine_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequestLine
    """
    return _datamodel.ArclinkRequestLine_ConstCast(*args)

def ArclinkRequestLine_Meta():
    r"""ArclinkRequestLine_Meta() -> MetaObject"""
    return _datamodel.ArclinkRequestLine_Meta()

class ArclinkRequestIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequestIndex 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__(ArclinkRequestIndex self) -> ArclinkRequestIndex
        __init__(ArclinkRequestIndex self, Time created, std::string const & requestID, std::string const & userID) -> ArclinkRequestIndex
        __init__(ArclinkRequestIndex self, ArclinkRequestIndex arg2) -> ArclinkRequestIndex
        """
        _datamodel.ArclinkRequestIndex_swiginit(self, _datamodel.new_ArclinkRequestIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(ArclinkRequestIndex self, ArclinkRequestIndex arg2) -> bool"""
        return _datamodel.ArclinkRequestIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(ArclinkRequestIndex self, ArclinkRequestIndex arg2) -> bool"""
        return _datamodel.ArclinkRequestIndex___ne__(self, arg2)
    created = property(_datamodel.ArclinkRequestIndex_created_get, _datamodel.ArclinkRequestIndex_created_set, doc=r"""created : Seiscomp::Core::Time""")
    requestID = property(_datamodel.ArclinkRequestIndex_requestID_get, _datamodel.ArclinkRequestIndex_requestID_set, doc=r"""requestID : std::string""")
    userID = property(_datamodel.ArclinkRequestIndex_userID_get, _datamodel.ArclinkRequestIndex_userID_set, doc=r"""userID : std::string""")
    __swig_destroy__ = _datamodel.delete_ArclinkRequestIndex

# Register ArclinkRequestIndex in _datamodel:
_datamodel.ArclinkRequestIndex_swigregister(ArclinkRequestIndex)

class ArclinkRequest(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequest 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 _datamodel.ArclinkRequest_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ArclinkRequest_TypeInfo()

    def className(self):
        r"""className(ArclinkRequest self) -> char const *"""
        return _datamodel.ArclinkRequest_className(self)

    def typeInfo(self):
        r"""typeInfo(ArclinkRequest self) -> RTTI"""
        return _datamodel.ArclinkRequest_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArclinkRequest
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequest
        """
        return _datamodel.ArclinkRequest_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArclinkRequest
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequest
        """
        return _datamodel.ArclinkRequest_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ArclinkRequest self, GenericArchive ar)"""
        return _datamodel.ArclinkRequest_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ArclinkRequest_Meta()

    def meta(self):
        r"""meta(ArclinkRequest self) -> MetaObject"""
        return _datamodel.ArclinkRequest_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ArclinkRequest self, ArclinkRequest other) -> ArclinkRequest
        __init__(ArclinkRequest self, std::string const & publicID) -> ArclinkRequest
        """
        _datamodel.ArclinkRequest_swiginit(self, _datamodel.new_ArclinkRequest(*args))
    __swig_destroy__ = _datamodel.delete_ArclinkRequest

    @staticmethod
    def Create(*args):
        r"""
        Create() -> ArclinkRequest
        Create(std::string const & publicID) -> ArclinkRequest
        """
        return _datamodel.ArclinkRequest_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> ArclinkRequest"""
        return _datamodel.ArclinkRequest_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(ArclinkRequest self, ArclinkRequest other) -> bool"""
        return _datamodel.ArclinkRequest___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ArclinkRequest self, ArclinkRequest other) -> bool"""
        return _datamodel.ArclinkRequest___ne__(self, other)

    def equal(self, other):
        r"""equal(ArclinkRequest self, ArclinkRequest other) -> bool"""
        return _datamodel.ArclinkRequest_equal(self, other)

    def setRequestID(self, requestID):
        r"""setRequestID(ArclinkRequest self, std::string const & requestID)"""
        return _datamodel.ArclinkRequest_setRequestID(self, requestID)

    def requestID(self):
        r"""requestID(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_requestID(self)

    def setUserID(self, userID):
        r"""setUserID(ArclinkRequest self, std::string const & userID)"""
        return _datamodel.ArclinkRequest_setUserID(self, userID)

    def userID(self):
        r"""userID(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_userID(self)

    def setUserIP(self, userIP):
        r"""setUserIP(ArclinkRequest self, std::string const & userIP)"""
        return _datamodel.ArclinkRequest_setUserIP(self, userIP)

    def userIP(self):
        r"""userIP(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_userIP(self)

    def setClientID(self, clientID):
        r"""setClientID(ArclinkRequest self, std::string const & clientID)"""
        return _datamodel.ArclinkRequest_setClientID(self, clientID)

    def clientID(self):
        r"""clientID(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_clientID(self)

    def setClientIP(self, clientIP):
        r"""setClientIP(ArclinkRequest self, std::string const & clientIP)"""
        return _datamodel.ArclinkRequest_setClientIP(self, clientIP)

    def clientIP(self):
        r"""clientIP(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_clientIP(self)

    def setType(self, type):
        r"""setType(ArclinkRequest self, std::string const & type)"""
        return _datamodel.ArclinkRequest_setType(self, type)

    def type(self):
        r"""type(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_type(self)

    def setCreated(self, created):
        r"""setCreated(ArclinkRequest self, Time created)"""
        return _datamodel.ArclinkRequest_setCreated(self, created)

    def created(self):
        r"""created(ArclinkRequest self) -> Time"""
        return _datamodel.ArclinkRequest_created(self)

    def setStatus(self, status):
        r"""setStatus(ArclinkRequest self, std::string const & status)"""
        return _datamodel.ArclinkRequest_setStatus(self, status)

    def status(self):
        r"""status(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_status(self)

    def setMessage(self, message):
        r"""setMessage(ArclinkRequest self, std::string const & message)"""
        return _datamodel.ArclinkRequest_setMessage(self, message)

    def message(self):
        r"""message(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_message(self)

    def setLabel(self, label):
        r"""setLabel(ArclinkRequest self, std::string const & label)"""
        return _datamodel.ArclinkRequest_setLabel(self, label)

    def label(self):
        r"""label(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_label(self)

    def setHeader(self, header):
        r"""setHeader(ArclinkRequest self, std::string const & header)"""
        return _datamodel.ArclinkRequest_setHeader(self, header)

    def header(self):
        r"""header(ArclinkRequest self) -> std::string const &"""
        return _datamodel.ArclinkRequest_header(self)

    def setSummary(self, summary):
        r"""setSummary(ArclinkRequest self, Seiscomp::Core::Optional< Seiscomp::DataModel::ArclinkRequestSummary >::Impl const & summary)"""
        return _datamodel.ArclinkRequest_setSummary(self, summary)

    def summary(self, *args):
        r"""
        summary(ArclinkRequest self) -> ArclinkRequestSummary
        summary(ArclinkRequest self) -> ArclinkRequestSummary
        """
        return _datamodel.ArclinkRequest_summary(self, *args)

    def index(self):
        r"""index(ArclinkRequest self) -> ArclinkRequestIndex"""
        return _datamodel.ArclinkRequest_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(ArclinkRequest self, ArclinkRequest lhs) -> bool"""
        return _datamodel.ArclinkRequest_equalIndex(self, lhs)

    def add(self, *args):
        r"""
        add(ArclinkRequest self, ArclinkStatusLine obj) -> bool
        add(ArclinkRequest self, ArclinkRequestLine obj) -> bool
        """
        return _datamodel.ArclinkRequest_add(self, *args)

    def remove(self, *args):
        r"""
        remove(ArclinkRequest self, ArclinkStatusLine obj) -> bool
        remove(ArclinkRequest self, ArclinkRequestLine obj) -> bool
        """
        return _datamodel.ArclinkRequest_remove(self, *args)

    def removeArclinkStatusLine(self, *args):
        r"""
        removeArclinkStatusLine(ArclinkRequest self, size_t i) -> bool
        removeArclinkStatusLine(ArclinkRequest self, ArclinkStatusLineIndex i) -> bool
        """
        return _datamodel.ArclinkRequest_removeArclinkStatusLine(self, *args)

    def removeArclinkRequestLine(self, *args):
        r"""
        removeArclinkRequestLine(ArclinkRequest self, size_t i) -> bool
        removeArclinkRequestLine(ArclinkRequest self, ArclinkRequestLineIndex i) -> bool
        """
        return _datamodel.ArclinkRequest_removeArclinkRequestLine(self, *args)

    def arclinkStatusLineCount(self):
        r"""arclinkStatusLineCount(ArclinkRequest self) -> size_t"""
        return _datamodel.ArclinkRequest_arclinkStatusLineCount(self)

    def arclinkRequestLineCount(self):
        r"""arclinkRequestLineCount(ArclinkRequest self) -> size_t"""
        return _datamodel.ArclinkRequest_arclinkRequestLineCount(self)

    def arclinkStatusLine(self, *args):
        r"""
        arclinkStatusLine(ArclinkRequest self, size_t i) -> ArclinkStatusLine
        arclinkStatusLine(ArclinkRequest self, ArclinkStatusLineIndex i) -> ArclinkStatusLine
        """
        return _datamodel.ArclinkRequest_arclinkStatusLine(self, *args)

    def arclinkRequestLine(self, *args):
        r"""
        arclinkRequestLine(ArclinkRequest self, size_t i) -> ArclinkRequestLine
        arclinkRequestLine(ArclinkRequest self, ArclinkRequestLineIndex i) -> ArclinkRequestLine
        """
        return _datamodel.ArclinkRequest_arclinkRequestLine(self, *args)

    def arclinkLog(self):
        r"""arclinkLog(ArclinkRequest self) -> ArclinkLog"""
        return _datamodel.ArclinkRequest_arclinkLog(self)

    def assign(self, other):
        r"""assign(ArclinkRequest self, Object other) -> bool"""
        return _datamodel.ArclinkRequest_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ArclinkRequest self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkRequest_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ArclinkRequest self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkRequest_detachFrom(self, parent)

    def detach(self):
        r"""detach(ArclinkRequest self) -> bool"""
        return _datamodel.ArclinkRequest_detach(self)

    def clone(self):
        r"""clone(ArclinkRequest self) -> Object"""
        return _datamodel.ArclinkRequest_clone(self)

    def updateChild(self, child):
        r"""updateChild(ArclinkRequest self, Object child) -> bool"""
        return _datamodel.ArclinkRequest_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ArclinkRequest self, Visitor visitor)"""
        return _datamodel.ArclinkRequest_accept(self, visitor)

# Register ArclinkRequest in _datamodel:
_datamodel.ArclinkRequest_swigregister(ArclinkRequest)

def ArclinkRequest_ClassName():
    r"""ArclinkRequest_ClassName() -> char const *"""
    return _datamodel.ArclinkRequest_ClassName()

def ArclinkRequest_TypeInfo():
    r"""ArclinkRequest_TypeInfo() -> RTTI"""
    return _datamodel.ArclinkRequest_TypeInfo()

def ArclinkRequest_Cast(*args):
    r"""
    ArclinkRequest_Cast(BaseObject o) -> ArclinkRequest
    ArclinkRequest_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequest
    """
    return _datamodel.ArclinkRequest_Cast(*args)

def ArclinkRequest_ConstCast(*args):
    r"""
    ArclinkRequest_ConstCast(BaseObject o) -> ArclinkRequest
    ArclinkRequest_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequest
    """
    return _datamodel.ArclinkRequest_ConstCast(*args)

def ArclinkRequest_Meta():
    r"""ArclinkRequest_Meta() -> MetaObject"""
    return _datamodel.ArclinkRequest_Meta()

def ArclinkRequest_Create(*args):
    r"""
    ArclinkRequest_Create() -> ArclinkRequest
    ArclinkRequest_Create(std::string const & publicID) -> ArclinkRequest
    """
    return _datamodel.ArclinkRequest_Create(*args)

def ArclinkRequest_Find(publicID):
    r"""ArclinkRequest_Find(std::string const & publicID) -> ArclinkRequest"""
    return _datamodel.ArclinkRequest_Find(publicID)

class ArclinkLog(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::ArclinkLog 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 _datamodel.ArclinkLog_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ArclinkLog_TypeInfo()

    def className(self):
        r"""className(ArclinkLog self) -> char const *"""
        return _datamodel.ArclinkLog_className(self)

    def typeInfo(self):
        r"""typeInfo(ArclinkLog self) -> RTTI"""
        return _datamodel.ArclinkLog_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArclinkLog
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkLog
        """
        return _datamodel.ArclinkLog_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArclinkLog
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkLog
        """
        return _datamodel.ArclinkLog_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ArclinkLog self, GenericArchive ar)"""
        return _datamodel.ArclinkLog_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.ArclinkLog_Meta()

    def meta(self):
        r"""meta(ArclinkLog self) -> MetaObject"""
        return _datamodel.ArclinkLog_meta(self)

    def __init__(self, *args):
        r"""
        __init__(ArclinkLog self) -> ArclinkLog
        __init__(ArclinkLog self, ArclinkLog other) -> ArclinkLog
        """
        _datamodel.ArclinkLog_swiginit(self, _datamodel.new_ArclinkLog(*args))
    __swig_destroy__ = _datamodel.delete_ArclinkLog

    def __eq__(self, other):
        r"""__eq__(ArclinkLog self, ArclinkLog other) -> bool"""
        return _datamodel.ArclinkLog___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(ArclinkLog self, ArclinkLog other) -> bool"""
        return _datamodel.ArclinkLog___ne__(self, other)

    def equal(self, other):
        r"""equal(ArclinkLog self, ArclinkLog other) -> bool"""
        return _datamodel.ArclinkLog_equal(self, other)

    def add(self, *args):
        r"""
        add(ArclinkLog self, ArclinkRequest obj) -> bool
        add(ArclinkLog self, ArclinkUser obj) -> bool
        """
        return _datamodel.ArclinkLog_add(self, *args)

    def remove(self, *args):
        r"""
        remove(ArclinkLog self, ArclinkRequest obj) -> bool
        remove(ArclinkLog self, ArclinkUser obj) -> bool
        """
        return _datamodel.ArclinkLog_remove(self, *args)

    def removeArclinkRequest(self, *args):
        r"""
        removeArclinkRequest(ArclinkLog self, size_t i) -> bool
        removeArclinkRequest(ArclinkLog self, ArclinkRequestIndex i) -> bool
        """
        return _datamodel.ArclinkLog_removeArclinkRequest(self, *args)

    def removeArclinkUser(self, *args):
        r"""
        removeArclinkUser(ArclinkLog self, size_t i) -> bool
        removeArclinkUser(ArclinkLog self, ArclinkUserIndex i) -> bool
        """
        return _datamodel.ArclinkLog_removeArclinkUser(self, *args)

    def arclinkRequestCount(self):
        r"""arclinkRequestCount(ArclinkLog self) -> size_t"""
        return _datamodel.ArclinkLog_arclinkRequestCount(self)

    def arclinkUserCount(self):
        r"""arclinkUserCount(ArclinkLog self) -> size_t"""
        return _datamodel.ArclinkLog_arclinkUserCount(self)

    def arclinkRequest(self, *args):
        r"""
        arclinkRequest(ArclinkLog self, size_t i) -> ArclinkRequest
        arclinkRequest(ArclinkLog self, ArclinkRequestIndex i) -> ArclinkRequest
        """
        return _datamodel.ArclinkLog_arclinkRequest(self, *args)

    def arclinkUser(self, *args):
        r"""
        arclinkUser(ArclinkLog self, size_t i) -> ArclinkUser
        arclinkUser(ArclinkLog self, ArclinkUserIndex i) -> ArclinkUser
        """
        return _datamodel.ArclinkLog_arclinkUser(self, *args)

    def findArclinkRequest(self, publicID):
        r"""findArclinkRequest(ArclinkLog self, std::string const & publicID) -> ArclinkRequest"""
        return _datamodel.ArclinkLog_findArclinkRequest(self, publicID)

    def findArclinkUser(self, publicID):
        r"""findArclinkUser(ArclinkLog self, std::string const & publicID) -> ArclinkUser"""
        return _datamodel.ArclinkLog_findArclinkUser(self, publicID)

    def assign(self, other):
        r"""assign(ArclinkLog self, Object other) -> bool"""
        return _datamodel.ArclinkLog_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(ArclinkLog self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkLog_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(ArclinkLog self, PublicObject parent) -> bool"""
        return _datamodel.ArclinkLog_detachFrom(self, parent)

    def detach(self):
        r"""detach(ArclinkLog self) -> bool"""
        return _datamodel.ArclinkLog_detach(self)

    def clone(self):
        r"""clone(ArclinkLog self) -> Object"""
        return _datamodel.ArclinkLog_clone(self)

    def updateChild(self, child):
        r"""updateChild(ArclinkLog self, Object child) -> bool"""
        return _datamodel.ArclinkLog_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(ArclinkLog self, Visitor visitor)"""
        return _datamodel.ArclinkLog_accept(self, visitor)

# Register ArclinkLog in _datamodel:
_datamodel.ArclinkLog_swigregister(ArclinkLog)

def ArclinkLog_ClassName():
    r"""ArclinkLog_ClassName() -> char const *"""
    return _datamodel.ArclinkLog_ClassName()

def ArclinkLog_TypeInfo():
    r"""ArclinkLog_TypeInfo() -> RTTI"""
    return _datamodel.ArclinkLog_TypeInfo()

def ArclinkLog_Cast(*args):
    r"""
    ArclinkLog_Cast(BaseObject o) -> ArclinkLog
    ArclinkLog_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkLog
    """
    return _datamodel.ArclinkLog_Cast(*args)

def ArclinkLog_ConstCast(*args):
    r"""
    ArclinkLog_ConstCast(BaseObject o) -> ArclinkLog
    ArclinkLog_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkLog
    """
    return _datamodel.ArclinkLog_ConstCast(*args)

def ArclinkLog_Meta():
    r"""ArclinkLog_Meta() -> MetaObject"""
    return _datamodel.ArclinkLog_Meta()

class DataSegmentIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::DataSegmentIndex 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__(DataSegmentIndex self) -> DataSegmentIndex
        __init__(DataSegmentIndex self, Time start) -> DataSegmentIndex
        __init__(DataSegmentIndex self, DataSegmentIndex arg2) -> DataSegmentIndex
        """
        _datamodel.DataSegmentIndex_swiginit(self, _datamodel.new_DataSegmentIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(DataSegmentIndex self, DataSegmentIndex arg2) -> bool"""
        return _datamodel.DataSegmentIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(DataSegmentIndex self, DataSegmentIndex arg2) -> bool"""
        return _datamodel.DataSegmentIndex___ne__(self, arg2)
    start = property(_datamodel.DataSegmentIndex_start_get, _datamodel.DataSegmentIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
    __swig_destroy__ = _datamodel.delete_DataSegmentIndex

# Register DataSegmentIndex in _datamodel:
_datamodel.DataSegmentIndex_swigregister(DataSegmentIndex)

class DataSegment(Object):
    r"""Proxy of C++ Seiscomp::DataModel::DataSegment 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 _datamodel.DataSegment_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.DataSegment_TypeInfo()

    def className(self):
        r"""className(DataSegment self) -> char const *"""
        return _datamodel.DataSegment_className(self)

    def typeInfo(self):
        r"""typeInfo(DataSegment self) -> RTTI"""
        return _datamodel.DataSegment_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DataSegment
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DataSegment
        """
        return _datamodel.DataSegment_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DataSegment
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataSegment
        """
        return _datamodel.DataSegment_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(DataSegment self, GenericArchive ar)"""
        return _datamodel.DataSegment_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.DataSegment_Meta()

    def meta(self):
        r"""meta(DataSegment self) -> MetaObject"""
        return _datamodel.DataSegment_meta(self)

    def __init__(self, *args):
        r"""
        __init__(DataSegment self) -> DataSegment
        __init__(DataSegment self, DataSegment other) -> DataSegment
        """
        _datamodel.DataSegment_swiginit(self, _datamodel.new_DataSegment(*args))
    __swig_destroy__ = _datamodel.delete_DataSegment

    def __eq__(self, other):
        r"""__eq__(DataSegment self, DataSegment other) -> bool"""
        return _datamodel.DataSegment___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(DataSegment self, DataSegment other) -> bool"""
        return _datamodel.DataSegment___ne__(self, other)

    def equal(self, other):
        r"""equal(DataSegment self, DataSegment other) -> bool"""
        return _datamodel.DataSegment_equal(self, other)

    def setStart(self, start):
        r"""setStart(DataSegment self, Time start)"""
        return _datamodel.DataSegment_setStart(self, start)

    def start(self):
        r"""start(DataSegment self) -> Time"""
        return _datamodel.DataSegment_start(self)

    def setEnd(self, end):
        r"""setEnd(DataSegment self, Time end)"""
        return _datamodel.DataSegment_setEnd(self, end)

    def end(self):
        r"""end(DataSegment self) -> Time"""
        return _datamodel.DataSegment_end(self)

    def setUpdated(self, updated):
        r"""setUpdated(DataSegment self, Time updated)"""
        return _datamodel.DataSegment_setUpdated(self, updated)

    def updated(self):
        r"""updated(DataSegment self) -> Time"""
        return _datamodel.DataSegment_updated(self)

    def setSampleRate(self, sampleRate):
        r"""setSampleRate(DataSegment self, double sampleRate)"""
        return _datamodel.DataSegment_setSampleRate(self, sampleRate)

    def sampleRate(self):
        r"""sampleRate(DataSegment self) -> double"""
        return _datamodel.DataSegment_sampleRate(self)

    def setQuality(self, quality):
        r"""setQuality(DataSegment self, std::string const & quality)"""
        return _datamodel.DataSegment_setQuality(self, quality)

    def quality(self):
        r"""quality(DataSegment self) -> std::string const &"""
        return _datamodel.DataSegment_quality(self)

    def setOutOfOrder(self, outOfOrder):
        r"""setOutOfOrder(DataSegment self, bool outOfOrder)"""
        return _datamodel.DataSegment_setOutOfOrder(self, outOfOrder)

    def outOfOrder(self):
        r"""outOfOrder(DataSegment self) -> bool"""
        return _datamodel.DataSegment_outOfOrder(self)

    def index(self):
        r"""index(DataSegment self) -> DataSegmentIndex"""
        return _datamodel.DataSegment_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(DataSegment self, DataSegment lhs) -> bool"""
        return _datamodel.DataSegment_equalIndex(self, lhs)

    def dataExtent(self):
        r"""dataExtent(DataSegment self) -> DataExtent"""
        return _datamodel.DataSegment_dataExtent(self)

    def assign(self, other):
        r"""assign(DataSegment self, Object other) -> bool"""
        return _datamodel.DataSegment_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(DataSegment self, PublicObject parent) -> bool"""
        return _datamodel.DataSegment_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(DataSegment self, PublicObject parent) -> bool"""
        return _datamodel.DataSegment_detachFrom(self, parent)

    def detach(self):
        r"""detach(DataSegment self) -> bool"""
        return _datamodel.DataSegment_detach(self)

    def clone(self):
        r"""clone(DataSegment self) -> Object"""
        return _datamodel.DataSegment_clone(self)

    def accept(self, visitor):
        r"""accept(DataSegment self, Visitor visitor)"""
        return _datamodel.DataSegment_accept(self, visitor)

# Register DataSegment in _datamodel:
_datamodel.DataSegment_swigregister(DataSegment)

def DataSegment_ClassName():
    r"""DataSegment_ClassName() -> char const *"""
    return _datamodel.DataSegment_ClassName()

def DataSegment_TypeInfo():
    r"""DataSegment_TypeInfo() -> RTTI"""
    return _datamodel.DataSegment_TypeInfo()

def DataSegment_Cast(*args):
    r"""
    DataSegment_Cast(BaseObject o) -> DataSegment
    DataSegment_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataSegment
    """
    return _datamodel.DataSegment_Cast(*args)

def DataSegment_ConstCast(*args):
    r"""
    DataSegment_ConstCast(BaseObject o) -> DataSegment
    DataSegment_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataSegment
    """
    return _datamodel.DataSegment_ConstCast(*args)

def DataSegment_Meta():
    r"""DataSegment_Meta() -> MetaObject"""
    return _datamodel.DataSegment_Meta()

class DataAttributeExtentIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::DataAttributeExtentIndex 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__(DataAttributeExtentIndex self) -> DataAttributeExtentIndex
        __init__(DataAttributeExtentIndex self, double sampleRate, std::string const & quality) -> DataAttributeExtentIndex
        __init__(DataAttributeExtentIndex self, DataAttributeExtentIndex arg2) -> DataAttributeExtentIndex
        """
        _datamodel.DataAttributeExtentIndex_swiginit(self, _datamodel.new_DataAttributeExtentIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(DataAttributeExtentIndex self, DataAttributeExtentIndex arg2) -> bool"""
        return _datamodel.DataAttributeExtentIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(DataAttributeExtentIndex self, DataAttributeExtentIndex arg2) -> bool"""
        return _datamodel.DataAttributeExtentIndex___ne__(self, arg2)
    sampleRate = property(_datamodel.DataAttributeExtentIndex_sampleRate_get, _datamodel.DataAttributeExtentIndex_sampleRate_set, doc=r"""sampleRate : double""")
    quality = property(_datamodel.DataAttributeExtentIndex_quality_get, _datamodel.DataAttributeExtentIndex_quality_set, doc=r"""quality : std::string""")
    __swig_destroy__ = _datamodel.delete_DataAttributeExtentIndex

# Register DataAttributeExtentIndex in _datamodel:
_datamodel.DataAttributeExtentIndex_swigregister(DataAttributeExtentIndex)

class DataAttributeExtent(Object):
    r"""Proxy of C++ Seiscomp::DataModel::DataAttributeExtent 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 _datamodel.DataAttributeExtent_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.DataAttributeExtent_TypeInfo()

    def className(self):
        r"""className(DataAttributeExtent self) -> char const *"""
        return _datamodel.DataAttributeExtent_className(self)

    def typeInfo(self):
        r"""typeInfo(DataAttributeExtent self) -> RTTI"""
        return _datamodel.DataAttributeExtent_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DataAttributeExtent
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DataAttributeExtent
        """
        return _datamodel.DataAttributeExtent_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DataAttributeExtent
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataAttributeExtent
        """
        return _datamodel.DataAttributeExtent_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(DataAttributeExtent self, GenericArchive ar)"""
        return _datamodel.DataAttributeExtent_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.DataAttributeExtent_Meta()

    def meta(self):
        r"""meta(DataAttributeExtent self) -> MetaObject"""
        return _datamodel.DataAttributeExtent_meta(self)

    def __init__(self, *args):
        r"""
        __init__(DataAttributeExtent self) -> DataAttributeExtent
        __init__(DataAttributeExtent self, DataAttributeExtent other) -> DataAttributeExtent
        """
        _datamodel.DataAttributeExtent_swiginit(self, _datamodel.new_DataAttributeExtent(*args))
    __swig_destroy__ = _datamodel.delete_DataAttributeExtent

    def __eq__(self, other):
        r"""__eq__(DataAttributeExtent self, DataAttributeExtent other) -> bool"""
        return _datamodel.DataAttributeExtent___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(DataAttributeExtent self, DataAttributeExtent other) -> bool"""
        return _datamodel.DataAttributeExtent___ne__(self, other)

    def equal(self, other):
        r"""equal(DataAttributeExtent self, DataAttributeExtent other) -> bool"""
        return _datamodel.DataAttributeExtent_equal(self, other)

    def setStart(self, start):
        r"""setStart(DataAttributeExtent self, Time start)"""
        return _datamodel.DataAttributeExtent_setStart(self, start)

    def start(self):
        r"""start(DataAttributeExtent self) -> Time"""
        return _datamodel.DataAttributeExtent_start(self)

    def setEnd(self, end):
        r"""setEnd(DataAttributeExtent self, Time end)"""
        return _datamodel.DataAttributeExtent_setEnd(self, end)

    def end(self):
        r"""end(DataAttributeExtent self) -> Time"""
        return _datamodel.DataAttributeExtent_end(self)

    def setSampleRate(self, sampleRate):
        r"""setSampleRate(DataAttributeExtent self, double sampleRate)"""
        return _datamodel.DataAttributeExtent_setSampleRate(self, sampleRate)

    def sampleRate(self):
        r"""sampleRate(DataAttributeExtent self) -> double"""
        return _datamodel.DataAttributeExtent_sampleRate(self)

    def setQuality(self, quality):
        r"""setQuality(DataAttributeExtent self, std::string const & quality)"""
        return _datamodel.DataAttributeExtent_setQuality(self, quality)

    def quality(self):
        r"""quality(DataAttributeExtent self) -> std::string const &"""
        return _datamodel.DataAttributeExtent_quality(self)

    def setUpdated(self, updated):
        r"""setUpdated(DataAttributeExtent self, Time updated)"""
        return _datamodel.DataAttributeExtent_setUpdated(self, updated)

    def updated(self):
        r"""updated(DataAttributeExtent self) -> Time"""
        return _datamodel.DataAttributeExtent_updated(self)

    def setSegmentCount(self, segmentCount):
        r"""setSegmentCount(DataAttributeExtent self, int segmentCount)"""
        return _datamodel.DataAttributeExtent_setSegmentCount(self, segmentCount)

    def segmentCount(self):
        r"""segmentCount(DataAttributeExtent self) -> int"""
        return _datamodel.DataAttributeExtent_segmentCount(self)

    def index(self):
        r"""index(DataAttributeExtent self) -> DataAttributeExtentIndex"""
        return _datamodel.DataAttributeExtent_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(DataAttributeExtent self, DataAttributeExtent lhs) -> bool"""
        return _datamodel.DataAttributeExtent_equalIndex(self, lhs)

    def dataExtent(self):
        r"""dataExtent(DataAttributeExtent self) -> DataExtent"""
        return _datamodel.DataAttributeExtent_dataExtent(self)

    def assign(self, other):
        r"""assign(DataAttributeExtent self, Object other) -> bool"""
        return _datamodel.DataAttributeExtent_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(DataAttributeExtent self, PublicObject parent) -> bool"""
        return _datamodel.DataAttributeExtent_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(DataAttributeExtent self, PublicObject parent) -> bool"""
        return _datamodel.DataAttributeExtent_detachFrom(self, parent)

    def detach(self):
        r"""detach(DataAttributeExtent self) -> bool"""
        return _datamodel.DataAttributeExtent_detach(self)

    def clone(self):
        r"""clone(DataAttributeExtent self) -> Object"""
        return _datamodel.DataAttributeExtent_clone(self)

    def accept(self, visitor):
        r"""accept(DataAttributeExtent self, Visitor visitor)"""
        return _datamodel.DataAttributeExtent_accept(self, visitor)

# Register DataAttributeExtent in _datamodel:
_datamodel.DataAttributeExtent_swigregister(DataAttributeExtent)

def DataAttributeExtent_ClassName():
    r"""DataAttributeExtent_ClassName() -> char const *"""
    return _datamodel.DataAttributeExtent_ClassName()

def DataAttributeExtent_TypeInfo():
    r"""DataAttributeExtent_TypeInfo() -> RTTI"""
    return _datamodel.DataAttributeExtent_TypeInfo()

def DataAttributeExtent_Cast(*args):
    r"""
    DataAttributeExtent_Cast(BaseObject o) -> DataAttributeExtent
    DataAttributeExtent_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataAttributeExtent
    """
    return _datamodel.DataAttributeExtent_Cast(*args)

def DataAttributeExtent_ConstCast(*args):
    r"""
    DataAttributeExtent_ConstCast(BaseObject o) -> DataAttributeExtent
    DataAttributeExtent_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataAttributeExtent
    """
    return _datamodel.DataAttributeExtent_ConstCast(*args)

def DataAttributeExtent_Meta():
    r"""DataAttributeExtent_Meta() -> MetaObject"""
    return _datamodel.DataAttributeExtent_Meta()

class DataExtentIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::DataExtentIndex 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__(DataExtentIndex self) -> DataExtentIndex
        __init__(DataExtentIndex self, WaveformStreamID waveformID) -> DataExtentIndex
        __init__(DataExtentIndex self, DataExtentIndex arg2) -> DataExtentIndex
        """
        _datamodel.DataExtentIndex_swiginit(self, _datamodel.new_DataExtentIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(DataExtentIndex self, DataExtentIndex arg2) -> bool"""
        return _datamodel.DataExtentIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(DataExtentIndex self, DataExtentIndex arg2) -> bool"""
        return _datamodel.DataExtentIndex___ne__(self, arg2)
    waveformID = property(_datamodel.DataExtentIndex_waveformID_get, _datamodel.DataExtentIndex_waveformID_set, doc=r"""waveformID : Seiscomp::DataModel::WaveformStreamID""")
    __swig_destroy__ = _datamodel.delete_DataExtentIndex

# Register DataExtentIndex in _datamodel:
_datamodel.DataExtentIndex_swigregister(DataExtentIndex)

class DataExtent(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::DataExtent 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 _datamodel.DataExtent_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.DataExtent_TypeInfo()

    def className(self):
        r"""className(DataExtent self) -> char const *"""
        return _datamodel.DataExtent_className(self)

    def typeInfo(self):
        r"""typeInfo(DataExtent self) -> RTTI"""
        return _datamodel.DataExtent_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DataExtent
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DataExtent
        """
        return _datamodel.DataExtent_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DataExtent
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataExtent
        """
        return _datamodel.DataExtent_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(DataExtent self, GenericArchive ar)"""
        return _datamodel.DataExtent_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.DataExtent_Meta()

    def meta(self):
        r"""meta(DataExtent self) -> MetaObject"""
        return _datamodel.DataExtent_meta(self)

    def __init__(self, *args):
        r"""
        __init__(DataExtent self, DataExtent other) -> DataExtent
        __init__(DataExtent self, std::string const & publicID) -> DataExtent
        """
        _datamodel.DataExtent_swiginit(self, _datamodel.new_DataExtent(*args))
    __swig_destroy__ = _datamodel.delete_DataExtent

    @staticmethod
    def Create(*args):
        r"""
        Create() -> DataExtent
        Create(std::string const & publicID) -> DataExtent
        """
        return _datamodel.DataExtent_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> DataExtent"""
        return _datamodel.DataExtent_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(DataExtent self, DataExtent other) -> bool"""
        return _datamodel.DataExtent___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(DataExtent self, DataExtent other) -> bool"""
        return _datamodel.DataExtent___ne__(self, other)

    def equal(self, other):
        r"""equal(DataExtent self, DataExtent other) -> bool"""
        return _datamodel.DataExtent_equal(self, other)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(DataExtent self, WaveformStreamID waveformID)"""
        return _datamodel.DataExtent_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(DataExtent self) -> WaveformStreamID
        waveformID(DataExtent self) -> WaveformStreamID
        """
        return _datamodel.DataExtent_waveformID(self, *args)

    def setStart(self, start):
        r"""setStart(DataExtent self, Time start)"""
        return _datamodel.DataExtent_setStart(self, start)

    def start(self):
        r"""start(DataExtent self) -> Time"""
        return _datamodel.DataExtent_start(self)

    def setEnd(self, end):
        r"""setEnd(DataExtent self, Time end)"""
        return _datamodel.DataExtent_setEnd(self, end)

    def end(self):
        r"""end(DataExtent self) -> Time"""
        return _datamodel.DataExtent_end(self)

    def setUpdated(self, updated):
        r"""setUpdated(DataExtent self, Time updated)"""
        return _datamodel.DataExtent_setUpdated(self, updated)

    def updated(self):
        r"""updated(DataExtent self) -> Time"""
        return _datamodel.DataExtent_updated(self)

    def setLastScan(self, lastScan):
        r"""setLastScan(DataExtent self, Time lastScan)"""
        return _datamodel.DataExtent_setLastScan(self, lastScan)

    def lastScan(self):
        r"""lastScan(DataExtent self) -> Time"""
        return _datamodel.DataExtent_lastScan(self)

    def setSegmentOverflow(self, segmentOverflow):
        r"""setSegmentOverflow(DataExtent self, bool segmentOverflow)"""
        return _datamodel.DataExtent_setSegmentOverflow(self, segmentOverflow)

    def segmentOverflow(self):
        r"""segmentOverflow(DataExtent self) -> bool"""
        return _datamodel.DataExtent_segmentOverflow(self)

    def index(self):
        r"""index(DataExtent self) -> DataExtentIndex"""
        return _datamodel.DataExtent_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(DataExtent self, DataExtent lhs) -> bool"""
        return _datamodel.DataExtent_equalIndex(self, lhs)

    def add(self, *args):
        r"""
        add(DataExtent self, DataSegment obj) -> bool
        add(DataExtent self, DataAttributeExtent obj) -> bool
        """
        return _datamodel.DataExtent_add(self, *args)

    def remove(self, *args):
        r"""
        remove(DataExtent self, DataSegment obj) -> bool
        remove(DataExtent self, DataAttributeExtent obj) -> bool
        """
        return _datamodel.DataExtent_remove(self, *args)

    def removeDataSegment(self, *args):
        r"""
        removeDataSegment(DataExtent self, size_t i) -> bool
        removeDataSegment(DataExtent self, DataSegmentIndex i) -> bool
        """
        return _datamodel.DataExtent_removeDataSegment(self, *args)

    def removeDataAttributeExtent(self, *args):
        r"""
        removeDataAttributeExtent(DataExtent self, size_t i) -> bool
        removeDataAttributeExtent(DataExtent self, DataAttributeExtentIndex i) -> bool
        """
        return _datamodel.DataExtent_removeDataAttributeExtent(self, *args)

    def dataSegmentCount(self):
        r"""dataSegmentCount(DataExtent self) -> size_t"""
        return _datamodel.DataExtent_dataSegmentCount(self)

    def dataAttributeExtentCount(self):
        r"""dataAttributeExtentCount(DataExtent self) -> size_t"""
        return _datamodel.DataExtent_dataAttributeExtentCount(self)

    def dataSegment(self, *args):
        r"""
        dataSegment(DataExtent self, size_t i) -> DataSegment
        dataSegment(DataExtent self, DataSegmentIndex i) -> DataSegment
        """
        return _datamodel.DataExtent_dataSegment(self, *args)

    def dataAttributeExtent(self, *args):
        r"""
        dataAttributeExtent(DataExtent self, size_t i) -> DataAttributeExtent
        dataAttributeExtent(DataExtent self, DataAttributeExtentIndex i) -> DataAttributeExtent
        """
        return _datamodel.DataExtent_dataAttributeExtent(self, *args)

    def dataAvailability(self):
        r"""dataAvailability(DataExtent self) -> DataAvailability"""
        return _datamodel.DataExtent_dataAvailability(self)

    def assign(self, other):
        r"""assign(DataExtent self, Object other) -> bool"""
        return _datamodel.DataExtent_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(DataExtent self, PublicObject parent) -> bool"""
        return _datamodel.DataExtent_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(DataExtent self, PublicObject parent) -> bool"""
        return _datamodel.DataExtent_detachFrom(self, parent)

    def detach(self):
        r"""detach(DataExtent self) -> bool"""
        return _datamodel.DataExtent_detach(self)

    def clone(self):
        r"""clone(DataExtent self) -> Object"""
        return _datamodel.DataExtent_clone(self)

    def updateChild(self, child):
        r"""updateChild(DataExtent self, Object child) -> bool"""
        return _datamodel.DataExtent_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(DataExtent self, Visitor visitor)"""
        return _datamodel.DataExtent_accept(self, visitor)

# Register DataExtent in _datamodel:
_datamodel.DataExtent_swigregister(DataExtent)

def DataExtent_ClassName():
    r"""DataExtent_ClassName() -> char const *"""
    return _datamodel.DataExtent_ClassName()

def DataExtent_TypeInfo():
    r"""DataExtent_TypeInfo() -> RTTI"""
    return _datamodel.DataExtent_TypeInfo()

def DataExtent_Cast(*args):
    r"""
    DataExtent_Cast(BaseObject o) -> DataExtent
    DataExtent_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataExtent
    """
    return _datamodel.DataExtent_Cast(*args)

def DataExtent_ConstCast(*args):
    r"""
    DataExtent_ConstCast(BaseObject o) -> DataExtent
    DataExtent_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataExtent
    """
    return _datamodel.DataExtent_ConstCast(*args)

def DataExtent_Meta():
    r"""DataExtent_Meta() -> MetaObject"""
    return _datamodel.DataExtent_Meta()

def DataExtent_Create(*args):
    r"""
    DataExtent_Create() -> DataExtent
    DataExtent_Create(std::string const & publicID) -> DataExtent
    """
    return _datamodel.DataExtent_Create(*args)

def DataExtent_Find(publicID):
    r"""DataExtent_Find(std::string const & publicID) -> DataExtent"""
    return _datamodel.DataExtent_Find(publicID)

class DataAvailability(PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::DataAvailability 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 _datamodel.DataAvailability_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.DataAvailability_TypeInfo()

    def className(self):
        r"""className(DataAvailability self) -> char const *"""
        return _datamodel.DataAvailability_className(self)

    def typeInfo(self):
        r"""typeInfo(DataAvailability self) -> RTTI"""
        return _datamodel.DataAvailability_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DataAvailability
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DataAvailability
        """
        return _datamodel.DataAvailability_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DataAvailability
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataAvailability
        """
        return _datamodel.DataAvailability_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(DataAvailability self, GenericArchive ar)"""
        return _datamodel.DataAvailability_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _datamodel.DataAvailability_Meta()

    def meta(self):
        r"""meta(DataAvailability self) -> MetaObject"""
        return _datamodel.DataAvailability_meta(self)

    def __init__(self, *args):
        r"""
        __init__(DataAvailability self) -> DataAvailability
        __init__(DataAvailability self, DataAvailability other) -> DataAvailability
        """
        _datamodel.DataAvailability_swiginit(self, _datamodel.new_DataAvailability(*args))
    __swig_destroy__ = _datamodel.delete_DataAvailability

    def __eq__(self, other):
        r"""__eq__(DataAvailability self, DataAvailability other) -> bool"""
        return _datamodel.DataAvailability___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(DataAvailability self, DataAvailability other) -> bool"""
        return _datamodel.DataAvailability___ne__(self, other)

    def equal(self, other):
        r"""equal(DataAvailability self, DataAvailability other) -> bool"""
        return _datamodel.DataAvailability_equal(self, other)

    def add(self, obj):
        r"""add(DataAvailability self, DataExtent obj) -> bool"""
        return _datamodel.DataAvailability_add(self, obj)

    def remove(self, obj):
        r"""remove(DataAvailability self, DataExtent obj) -> bool"""
        return _datamodel.DataAvailability_remove(self, obj)

    def removeDataExtent(self, *args):
        r"""
        removeDataExtent(DataAvailability self, size_t i) -> bool
        removeDataExtent(DataAvailability self, DataExtentIndex i) -> bool
        """
        return _datamodel.DataAvailability_removeDataExtent(self, *args)

    def dataExtentCount(self):
        r"""dataExtentCount(DataAvailability self) -> size_t"""
        return _datamodel.DataAvailability_dataExtentCount(self)

    def dataExtent(self, *args):
        r"""
        dataExtent(DataAvailability self, size_t i) -> DataExtent
        dataExtent(DataAvailability self, DataExtentIndex i) -> DataExtent
        """
        return _datamodel.DataAvailability_dataExtent(self, *args)

    def findDataExtent(self, publicID):
        r"""findDataExtent(DataAvailability self, std::string const & publicID) -> DataExtent"""
        return _datamodel.DataAvailability_findDataExtent(self, publicID)

    def assign(self, other):
        r"""assign(DataAvailability self, Object other) -> bool"""
        return _datamodel.DataAvailability_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(DataAvailability self, PublicObject parent) -> bool"""
        return _datamodel.DataAvailability_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(DataAvailability self, PublicObject parent) -> bool"""
        return _datamodel.DataAvailability_detachFrom(self, parent)

    def detach(self):
        r"""detach(DataAvailability self) -> bool"""
        return _datamodel.DataAvailability_detach(self)

    def clone(self):
        r"""clone(DataAvailability self) -> Object"""
        return _datamodel.DataAvailability_clone(self)

    def updateChild(self, child):
        r"""updateChild(DataAvailability self, Object child) -> bool"""
        return _datamodel.DataAvailability_updateChild(self, child)

    def accept(self, visitor):
        r"""accept(DataAvailability self, Visitor visitor)"""
        return _datamodel.DataAvailability_accept(self, visitor)

# Register DataAvailability in _datamodel:
_datamodel.DataAvailability_swigregister(DataAvailability)

def DataAvailability_ClassName():
    r"""DataAvailability_ClassName() -> char const *"""
    return _datamodel.DataAvailability_ClassName()

def DataAvailability_TypeInfo():
    r"""DataAvailability_TypeInfo() -> RTTI"""
    return _datamodel.DataAvailability_TypeInfo()

def DataAvailability_Cast(*args):
    r"""
    DataAvailability_Cast(BaseObject o) -> DataAvailability
    DataAvailability_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataAvailability
    """
    return _datamodel.DataAvailability_Cast(*args)

def DataAvailability_ConstCast(*args):
    r"""
    DataAvailability_ConstCast(BaseObject o) -> DataAvailability
    DataAvailability_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataAvailability
    """
    return _datamodel.DataAvailability_ConstCast(*args)

def DataAvailability_Meta():
    r"""DataAvailability_Meta() -> MetaObject"""
    return _datamodel.DataAvailability_Meta()

class DatabaseReader(DatabaseArchive):
    r"""Proxy of C++ Seiscomp::DataModel::DatabaseReader 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, dbDriver):
        r"""__init__(DatabaseReader self, DatabaseInterface dbDriver) -> DatabaseReader"""
        _datamodel.DatabaseReader_swiginit(self, _datamodel.new_DatabaseReader(dbDriver))
    __swig_destroy__ = _datamodel.delete_DatabaseReader

    def loadObject(self, classType, publicID):
        r"""loadObject(DatabaseReader self, RTTI classType, std::string const & publicID) -> PublicObject"""
        return _datamodel.DatabaseReader_loadObject(self, classType, publicID)

    def loadEventParameters(self):
        r"""loadEventParameters(DatabaseReader self) -> EventParameters"""
        return _datamodel.DatabaseReader_loadEventParameters(self)

    def loadPicks(self, arg2):
        r"""loadPicks(DatabaseReader self, EventParameters arg2) -> int"""
        return _datamodel.DatabaseReader_loadPicks(self, arg2)

    def loadAmplitudes(self, arg2):
        r"""loadAmplitudes(DatabaseReader self, EventParameters arg2) -> int"""
        return _datamodel.DatabaseReader_loadAmplitudes(self, arg2)

    def loadReadings(self, arg2):
        r"""loadReadings(DatabaseReader self, EventParameters arg2) -> int"""
        return _datamodel.DatabaseReader_loadReadings(self, arg2)

    def loadOrigins(self, arg2):
        r"""loadOrigins(DatabaseReader self, EventParameters arg2) -> int"""
        return _datamodel.DatabaseReader_loadOrigins(self, arg2)

    def loadFocalMechanisms(self, arg2):
        r"""loadFocalMechanisms(DatabaseReader self, EventParameters arg2) -> int"""
        return _datamodel.DatabaseReader_loadFocalMechanisms(self, arg2)

    def loadEvents(self, arg2):
        r"""loadEvents(DatabaseReader self, EventParameters arg2) -> int"""
        return _datamodel.DatabaseReader_loadEvents(self, arg2)

    def loadPickReferences(self, arg2):
        r"""loadPickReferences(DatabaseReader self, Reading arg2) -> int"""
        return _datamodel.DatabaseReader_loadPickReferences(self, arg2)

    def loadAmplitudeReferences(self, arg2):
        r"""loadAmplitudeReferences(DatabaseReader self, Reading arg2) -> int"""
        return _datamodel.DatabaseReader_loadAmplitudeReferences(self, arg2)

    def loadCompositeTimes(self, arg2):
        r"""loadCompositeTimes(DatabaseReader self, Origin arg2) -> int"""
        return _datamodel.DatabaseReader_loadCompositeTimes(self, arg2)

    def loadArrivals(self, arg2):
        r"""loadArrivals(DatabaseReader self, Origin arg2) -> int"""
        return _datamodel.DatabaseReader_loadArrivals(self, arg2)

    def loadStationMagnitudes(self, arg2):
        r"""loadStationMagnitudes(DatabaseReader self, Origin arg2) -> int"""
        return _datamodel.DatabaseReader_loadStationMagnitudes(self, arg2)

    def loadMagnitudes(self, arg2):
        r"""loadMagnitudes(DatabaseReader self, Origin arg2) -> int"""
        return _datamodel.DatabaseReader_loadMagnitudes(self, arg2)

    def loadStationMagnitudeContributions(self, arg2):
        r"""loadStationMagnitudeContributions(DatabaseReader self, Magnitude arg2) -> int"""
        return _datamodel.DatabaseReader_loadStationMagnitudeContributions(self, arg2)

    def loadMomentTensors(self, arg2):
        r"""loadMomentTensors(DatabaseReader self, FocalMechanism arg2) -> int"""
        return _datamodel.DatabaseReader_loadMomentTensors(self, arg2)

    def loadDataUseds(self, arg2):
        r"""loadDataUseds(DatabaseReader self, MomentTensor arg2) -> int"""
        return _datamodel.DatabaseReader_loadDataUseds(self, arg2)

    def loadMomentTensorPhaseSettings(self, arg2):
        r"""loadMomentTensorPhaseSettings(DatabaseReader self, MomentTensor arg2) -> int"""
        return _datamodel.DatabaseReader_loadMomentTensorPhaseSettings(self, arg2)

    def loadMomentTensorStationContributions(self, arg2):
        r"""loadMomentTensorStationContributions(DatabaseReader self, MomentTensor arg2) -> int"""
        return _datamodel.DatabaseReader_loadMomentTensorStationContributions(self, arg2)

    def loadMomentTensorComponentContributions(self, arg2):
        r"""loadMomentTensorComponentContributions(DatabaseReader self, MomentTensorStationContribution arg2) -> int"""
        return _datamodel.DatabaseReader_loadMomentTensorComponentContributions(self, arg2)

    def loadEventDescriptions(self, arg2):
        r"""loadEventDescriptions(DatabaseReader self, Event arg2) -> int"""
        return _datamodel.DatabaseReader_loadEventDescriptions(self, arg2)

    def loadOriginReferences(self, arg2):
        r"""loadOriginReferences(DatabaseReader self, Event arg2) -> int"""
        return _datamodel.DatabaseReader_loadOriginReferences(self, arg2)

    def loadFocalMechanismReferences(self, arg2):
        r"""loadFocalMechanismReferences(DatabaseReader self, Event arg2) -> int"""
        return _datamodel.DatabaseReader_loadFocalMechanismReferences(self, arg2)

    def loadConfig(self):
        r"""loadConfig(DatabaseReader self) -> Config"""
        return _datamodel.DatabaseReader_loadConfig(self)

    def loadParameterSets(self, arg2):
        r"""loadParameterSets(DatabaseReader self, Config arg2) -> int"""
        return _datamodel.DatabaseReader_loadParameterSets(self, arg2)

    def loadConfigModules(self, arg2):
        r"""loadConfigModules(DatabaseReader self, Config arg2) -> int"""
        return _datamodel.DatabaseReader_loadConfigModules(self, arg2)

    def loadParameters(self, arg2):
        r"""loadParameters(DatabaseReader self, ParameterSet arg2) -> int"""
        return _datamodel.DatabaseReader_loadParameters(self, arg2)

    def loadConfigStations(self, arg2):
        r"""loadConfigStations(DatabaseReader self, ConfigModule arg2) -> int"""
        return _datamodel.DatabaseReader_loadConfigStations(self, arg2)

    def loadSetups(self, arg2):
        r"""loadSetups(DatabaseReader self, ConfigStation arg2) -> int"""
        return _datamodel.DatabaseReader_loadSetups(self, arg2)

    def loadQualityControl(self):
        r"""loadQualityControl(DatabaseReader self) -> QualityControl"""
        return _datamodel.DatabaseReader_loadQualityControl(self)

    def loadQCLogs(self, arg2):
        r"""loadQCLogs(DatabaseReader self, QualityControl arg2) -> int"""
        return _datamodel.DatabaseReader_loadQCLogs(self, arg2)

    def loadWaveformQualitys(self, arg2):
        r"""loadWaveformQualitys(DatabaseReader self, QualityControl arg2) -> int"""
        return _datamodel.DatabaseReader_loadWaveformQualitys(self, arg2)

    def loadOutages(self, arg2):
        r"""loadOutages(DatabaseReader self, QualityControl arg2) -> int"""
        return _datamodel.DatabaseReader_loadOutages(self, arg2)

    def loadInventory(self):
        r"""loadInventory(DatabaseReader self) -> Inventory"""
        return _datamodel.DatabaseReader_loadInventory(self)

    def loadStationGroups(self, arg2):
        r"""loadStationGroups(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadStationGroups(self, arg2)

    def loadAuxDevices(self, arg2):
        r"""loadAuxDevices(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadAuxDevices(self, arg2)

    def loadSensors(self, arg2):
        r"""loadSensors(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadSensors(self, arg2)

    def loadDataloggers(self, arg2):
        r"""loadDataloggers(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadDataloggers(self, arg2)

    def loadResponsePAZs(self, arg2):
        r"""loadResponsePAZs(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadResponsePAZs(self, arg2)

    def loadResponseFIRs(self, arg2):
        r"""loadResponseFIRs(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadResponseFIRs(self, arg2)

    def loadResponseIIRs(self, arg2):
        r"""loadResponseIIRs(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadResponseIIRs(self, arg2)

    def loadResponsePolynomials(self, arg2):
        r"""loadResponsePolynomials(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadResponsePolynomials(self, arg2)

    def loadResponseFAPs(self, arg2):
        r"""loadResponseFAPs(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadResponseFAPs(self, arg2)

    def loadNetworks(self, arg2):
        r"""loadNetworks(DatabaseReader self, Inventory arg2) -> int"""
        return _datamodel.DatabaseReader_loadNetworks(self, arg2)

    def loadStationReferences(self, arg2):
        r"""loadStationReferences(DatabaseReader self, StationGroup arg2) -> int"""
        return _datamodel.DatabaseReader_loadStationReferences(self, arg2)

    def loadAuxSources(self, arg2):
        r"""loadAuxSources(DatabaseReader self, AuxDevice arg2) -> int"""
        return _datamodel.DatabaseReader_loadAuxSources(self, arg2)

    def loadSensorCalibrations(self, arg2):
        r"""loadSensorCalibrations(DatabaseReader self, Sensor arg2) -> int"""
        return _datamodel.DatabaseReader_loadSensorCalibrations(self, arg2)

    def loadDataloggerCalibrations(self, arg2):
        r"""loadDataloggerCalibrations(DatabaseReader self, Datalogger arg2) -> int"""
        return _datamodel.DatabaseReader_loadDataloggerCalibrations(self, arg2)

    def loadDecimations(self, arg2):
        r"""loadDecimations(DatabaseReader self, Datalogger arg2) -> int"""
        return _datamodel.DatabaseReader_loadDecimations(self, arg2)

    def loadStations(self, arg2):
        r"""loadStations(DatabaseReader self, Network arg2) -> int"""
        return _datamodel.DatabaseReader_loadStations(self, arg2)

    def loadSensorLocations(self, arg2):
        r"""loadSensorLocations(DatabaseReader self, Station arg2) -> int"""
        return _datamodel.DatabaseReader_loadSensorLocations(self, arg2)

    def loadAuxStreams(self, arg2):
        r"""loadAuxStreams(DatabaseReader self, SensorLocation arg2) -> int"""
        return _datamodel.DatabaseReader_loadAuxStreams(self, arg2)

    def loadStreams(self, arg2):
        r"""loadStreams(DatabaseReader self, SensorLocation arg2) -> int"""
        return _datamodel.DatabaseReader_loadStreams(self, arg2)

    def loadComments(self, *args):
        r"""
        loadComments(DatabaseReader self, Pick arg2) -> int
        loadComments(DatabaseReader self, Amplitude arg2) -> int
        loadComments(DatabaseReader self, Origin arg2) -> int
        loadComments(DatabaseReader self, StationMagnitude arg2) -> int
        loadComments(DatabaseReader self, Magnitude arg2) -> int
        loadComments(DatabaseReader self, FocalMechanism arg2) -> int
        loadComments(DatabaseReader self, MomentTensor arg2) -> int
        loadComments(DatabaseReader self, Event arg2) -> int
        loadComments(DatabaseReader self, ParameterSet arg2) -> int
        loadComments(DatabaseReader self, Parameter arg2) -> int
        loadComments(DatabaseReader self, Network arg2) -> int
        loadComments(DatabaseReader self, Station arg2) -> int
        loadComments(DatabaseReader self, SensorLocation arg2) -> int
        loadComments(DatabaseReader self, Stream arg2) -> int
        """
        return _datamodel.DatabaseReader_loadComments(self, *args)

    def loadRouting(self):
        r"""loadRouting(DatabaseReader self) -> Routing"""
        return _datamodel.DatabaseReader_loadRouting(self)

    def loadRoutes(self, arg2):
        r"""loadRoutes(DatabaseReader self, Routing arg2) -> int"""
        return _datamodel.DatabaseReader_loadRoutes(self, arg2)

    def loadAccesss(self, arg2):
        r"""loadAccesss(DatabaseReader self, Routing arg2) -> int"""
        return _datamodel.DatabaseReader_loadAccesss(self, arg2)

    def loadRouteArclinks(self, arg2):
        r"""loadRouteArclinks(DatabaseReader self, Route arg2) -> int"""
        return _datamodel.DatabaseReader_loadRouteArclinks(self, arg2)

    def loadRouteSeedlinks(self, arg2):
        r"""loadRouteSeedlinks(DatabaseReader self, Route arg2) -> int"""
        return _datamodel.DatabaseReader_loadRouteSeedlinks(self, arg2)

    def loadJournaling(self):
        r"""loadJournaling(DatabaseReader self) -> Journaling"""
        return _datamodel.DatabaseReader_loadJournaling(self)

    def loadJournalEntrys(self, arg2):
        r"""loadJournalEntrys(DatabaseReader self, Journaling arg2) -> int"""
        return _datamodel.DatabaseReader_loadJournalEntrys(self, arg2)

    def loadArclinkLog(self):
        r"""loadArclinkLog(DatabaseReader self) -> ArclinkLog"""
        return _datamodel.DatabaseReader_loadArclinkLog(self)

    def loadArclinkRequests(self, arg2):
        r"""loadArclinkRequests(DatabaseReader self, ArclinkLog arg2) -> int"""
        return _datamodel.DatabaseReader_loadArclinkRequests(self, arg2)

    def loadArclinkUsers(self, arg2):
        r"""loadArclinkUsers(DatabaseReader self, ArclinkLog arg2) -> int"""
        return _datamodel.DatabaseReader_loadArclinkUsers(self, arg2)

    def loadArclinkStatusLines(self, arg2):
        r"""loadArclinkStatusLines(DatabaseReader self, ArclinkRequest arg2) -> int"""
        return _datamodel.DatabaseReader_loadArclinkStatusLines(self, arg2)

    def loadArclinkRequestLines(self, arg2):
        r"""loadArclinkRequestLines(DatabaseReader self, ArclinkRequest arg2) -> int"""
        return _datamodel.DatabaseReader_loadArclinkRequestLines(self, arg2)

    def loadDataAvailability(self):
        r"""loadDataAvailability(DatabaseReader self) -> DataAvailability"""
        return _datamodel.DatabaseReader_loadDataAvailability(self)

    def loadDataExtents(self, arg2):
        r"""loadDataExtents(DatabaseReader self, DataAvailability arg2) -> int"""
        return _datamodel.DatabaseReader_loadDataExtents(self, arg2)

    def load(self, *args):
        r"""
        load(DatabaseReader self, EventParameters arg2) -> int
        load(DatabaseReader self, Pick arg2) -> int
        load(DatabaseReader self, Amplitude arg2) -> int
        load(DatabaseReader self, Reading arg2) -> int
        load(DatabaseReader self, Origin arg2) -> int
        load(DatabaseReader self, StationMagnitude arg2) -> int
        load(DatabaseReader self, Magnitude arg2) -> int
        load(DatabaseReader self, FocalMechanism arg2) -> int
        load(DatabaseReader self, MomentTensor arg2) -> int
        load(DatabaseReader self, MomentTensorStationContribution arg2) -> int
        load(DatabaseReader self, Event arg2) -> int
        load(DatabaseReader self, Config arg2) -> int
        load(DatabaseReader self, ParameterSet arg2) -> int
        load(DatabaseReader self, Parameter arg2) -> int
        load(DatabaseReader self, ConfigModule arg2) -> int
        load(DatabaseReader self, ConfigStation arg2) -> int
        load(DatabaseReader self, QualityControl arg2) -> int
        load(DatabaseReader self, Inventory arg2) -> int
        load(DatabaseReader self, StationGroup arg2) -> int
        load(DatabaseReader self, AuxDevice arg2) -> int
        load(DatabaseReader self, Sensor arg2) -> int
        load(DatabaseReader self, Datalogger arg2) -> int
        load(DatabaseReader self, Network arg2) -> int
        load(DatabaseReader self, Station arg2) -> int
        load(DatabaseReader self, SensorLocation arg2) -> int
        load(DatabaseReader self, Stream arg2) -> int
        load(DatabaseReader self, Routing arg2) -> int
        load(DatabaseReader self, Route arg2) -> int
        load(DatabaseReader self, Journaling arg2) -> int
        load(DatabaseReader self, ArclinkLog arg2) -> int
        load(DatabaseReader self, ArclinkRequest arg2) -> int
        load(DatabaseReader self, DataAvailability arg2) -> int
        load(DatabaseReader self, DataExtent arg2) -> int
        """
        return _datamodel.DatabaseReader_load(self, *args)

    def loadDataSegments(self, arg2):
        r"""loadDataSegments(DatabaseReader self, DataExtent arg2) -> int"""
        return _datamodel.DatabaseReader_loadDataSegments(self, arg2)

    def loadDataAttributeExtents(self, arg2):
        r"""loadDataAttributeExtents(DatabaseReader self, DataExtent arg2) -> int"""
        return _datamodel.DatabaseReader_loadDataAttributeExtents(self, arg2)

# Register DatabaseReader in _datamodel:
_datamodel.DatabaseReader_swigregister(DatabaseReader)

class DatabaseQuery(DatabaseReader):
    r"""Proxy of C++ Seiscomp::DataModel::DatabaseQuery 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, dbDriver):
        r"""__init__(DatabaseQuery self, DatabaseInterface dbDriver) -> DatabaseQuery"""
        _datamodel.DatabaseQuery_swiginit(self, _datamodel.new_DatabaseQuery(dbDriver))
    __swig_destroy__ = _datamodel.delete_DatabaseQuery

    def getStation(self, network_code, station_code, time):
        r"""getStation(DatabaseQuery self, std::string const & network_code, std::string const & station_code, Time time) -> Station"""
        return _datamodel.DatabaseQuery_getStation(self, network_code, station_code, time)

    def getEvent(self, originID):
        r"""getEvent(DatabaseQuery self, std::string const & originID) -> Event"""
        return _datamodel.DatabaseQuery_getEvent(self, originID)

    def getEventByPreferredMagnitudeID(self, magnitudeID):
        r"""getEventByPreferredMagnitudeID(DatabaseQuery self, std::string const & magnitudeID) -> Event"""
        return _datamodel.DatabaseQuery_getEventByPreferredMagnitudeID(self, magnitudeID)

    def getEventForFocalMechanism(self, focalMechanismID):
        r"""getEventForFocalMechanism(DatabaseQuery self, std::string const & focalMechanismID) -> Event"""
        return _datamodel.DatabaseQuery_getEventForFocalMechanism(self, focalMechanismID)

    def getEventByPublicID(self, eventID):
        r"""getEventByPublicID(DatabaseQuery self, std::string const & eventID) -> Event"""
        return _datamodel.DatabaseQuery_getEventByPublicID(self, eventID)

    def getAmplitude(self, pickID, type):
        r"""getAmplitude(DatabaseQuery self, std::string const & pickID, std::string const & type) -> Amplitude"""
        return _datamodel.DatabaseQuery_getAmplitude(self, pickID, type)

    def getAmplitudes(self, startTime, endTime):
        r"""getAmplitudes(DatabaseQuery self, Time startTime, Time endTime) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getAmplitudes(self, startTime, endTime)

    def getAmplitudesForPick(self, pickID):
        r"""getAmplitudesForPick(DatabaseQuery self, std::string const & pickID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getAmplitudesForPick(self, pickID)

    def getAmplitudesForOrigin(self, originID):
        r"""getAmplitudesForOrigin(DatabaseQuery self, std::string const & originID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getAmplitudesForOrigin(self, originID)

    def getOriginsForAmplitude(self, amplitudeID):
        r"""getOriginsForAmplitude(DatabaseQuery self, std::string const & amplitudeID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getOriginsForAmplitude(self, amplitudeID)

    def getOriginByMagnitude(self, magnitudeID):
        r"""getOriginByMagnitude(DatabaseQuery self, std::string const & magnitudeID) -> Origin"""
        return _datamodel.DatabaseQuery_getOriginByMagnitude(self, magnitudeID)

    def getArrivalsForAmplitude(self, amplitudeID):
        r"""getArrivalsForAmplitude(DatabaseQuery self, std::string const & amplitudeID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getArrivalsForAmplitude(self, amplitudeID)

    def getPicks(self, *args):
        r"""
        getPicks(DatabaseQuery self, std::string const & originID) -> DatabaseIterator
        getPicks(DatabaseQuery self, Time startTime, Time endTime) -> DatabaseIterator
        getPicks(DatabaseQuery self, Time startTime, Time endTime, WaveformStreamID waveformID) -> DatabaseIterator
        """
        return _datamodel.DatabaseQuery_getPicks(self, *args)

    def getWaveformQuality(self, *args):
        r"""
        getWaveformQuality(DatabaseQuery self, std::string const & type) -> DatabaseIterator
        getWaveformQuality(DatabaseQuery self, WaveformStreamID waveformID, std::string const & parameter, Time startTime, Time endTime) -> DatabaseIterator
        getWaveformQuality(DatabaseQuery self, Time startTime, Time endTime) -> DatabaseIterator
        getWaveformQuality(DatabaseQuery self, WaveformStreamID waveformID, std::string const & parameter, std::string const & type, Time startTime, Time endTime) -> DatabaseIterator
        """
        return _datamodel.DatabaseQuery_getWaveformQuality(self, *args)

    def getWaveformQualityDescending(self, waveformID, parameter, type):
        r"""getWaveformQualityDescending(DatabaseQuery self, WaveformStreamID waveformID, std::string const & parameter, std::string const & type) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getWaveformQualityDescending(self, waveformID, parameter, type)

    def getOutage(self, waveformID, startTime, endTime):
        r"""getOutage(DatabaseQuery self, WaveformStreamID waveformID, Time startTime, Time endTime) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getOutage(self, waveformID, startTime, endTime)

    def getQCLog(self, waveformID, startTime, endTime):
        r"""getQCLog(DatabaseQuery self, WaveformStreamID waveformID, Time startTime, Time endTime) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getQCLog(self, waveformID, startTime, endTime)

    def getPreferredOrigins(self, startTime, endTime, referenceOriginID):
        r"""getPreferredOrigins(DatabaseQuery self, Time startTime, Time endTime, std::string const & referenceOriginID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getPreferredOrigins(self, startTime, endTime, referenceOriginID)

    def getPreferredMagnitudes(self, startTime, endTime, referenceMagnitudeID):
        r"""getPreferredMagnitudes(DatabaseQuery self, Time startTime, Time endTime, std::string const & referenceMagnitudeID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getPreferredMagnitudes(self, startTime, endTime, referenceMagnitudeID)

    def getEvents(self, startTime, endTime):
        r"""getEvents(DatabaseQuery self, Time startTime, Time endTime) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getEvents(self, startTime, endTime)

    def getOrigins(self, eventID):
        r"""getOrigins(DatabaseQuery self, std::string const & eventID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getOrigins(self, eventID)

    def getOriginsDescending(self, eventID):
        r"""getOriginsDescending(DatabaseQuery self, std::string const & eventID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getOriginsDescending(self, eventID)

    def getFocalMechanismsDescending(self, eventID):
        r"""getFocalMechanismsDescending(DatabaseQuery self, std::string const & eventID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getFocalMechanismsDescending(self, eventID)

    def getEventPickIDs(self, publicID):
        r"""getEventPickIDs(DatabaseQuery self, std::string const & publicID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getEventPickIDs(self, publicID)

    def getEventPickIDsByWeight(self, publicID, weight):
        r"""getEventPickIDsByWeight(DatabaseQuery self, std::string const & publicID, double weight) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getEventPickIDsByWeight(self, publicID, weight)

    def getEventPicks(self, eventID):
        r"""getEventPicks(DatabaseQuery self, std::string const & eventID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getEventPicks(self, eventID)

    def getEventPicksByWeight(self, publicID, weight):
        r"""getEventPicksByWeight(DatabaseQuery self, std::string const & publicID, double weight) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getEventPicksByWeight(self, publicID, weight)

    def getConfigModule(self, name, enabled):
        r"""getConfigModule(DatabaseQuery self, std::string const & name, bool enabled) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getConfigModule(self, name, enabled)

    def getEquivalentPick(self, stationCode, networkCode, locationCode, channelCode, startTime, endTime):
        r"""getEquivalentPick(DatabaseQuery self, std::string const & stationCode, std::string const & networkCode, std::string const & locationCode, std::string const & channelCode, Time startTime, Time endTime) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getEquivalentPick(self, stationCode, networkCode, locationCode, channelCode, startTime, endTime)

    def getJournal(self, objectID):
        r"""getJournal(DatabaseQuery self, std::string const & objectID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getJournal(self, objectID)

    def getJournalAction(self, objectID, action):
        r"""getJournalAction(DatabaseQuery self, std::string const & objectID, std::string const & action) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getJournalAction(self, objectID, action)

    def getArclinkRequestByStreamCode(self, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type):
        r"""getArclinkRequestByStreamCode(DatabaseQuery self, Time startTime, Time endTime, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, std::string const & type) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getArclinkRequestByStreamCode(self, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type)

    def getArclinkRequestByRequestID(self, requestID):
        r"""getArclinkRequestByRequestID(DatabaseQuery self, std::string const & requestID) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getArclinkRequestByRequestID(self, requestID)

    def getArclinkRequestByUserID(self, userID, startTime, endTime, type):
        r"""getArclinkRequestByUserID(DatabaseQuery self, std::string const & userID, Time startTime, Time endTime, std::string const & type) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getArclinkRequestByUserID(self, userID, startTime, endTime, type)

    def getArclinkRequestByTime(self, startTime, endTime, type):
        r"""getArclinkRequestByTime(DatabaseQuery self, Time startTime, Time endTime, std::string const & type) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getArclinkRequestByTime(self, startTime, endTime, type)

    def getArclinkRequest(self, userID, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type, netClass):
        r"""getArclinkRequest(DatabaseQuery self, std::string const & userID, Time startTime, Time endTime, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, std::string const & type, std::string const & netClass) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getArclinkRequest(self, userID, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type, netClass)

    def getArclinkRequestRestricted(self, userID, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type, netClass, restricted):
        r"""getArclinkRequestRestricted(DatabaseQuery self, std::string const & userID, Time startTime, Time endTime, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, std::string const & type, std::string const & netClass, bool restricted) -> DatabaseIterator"""
        return _datamodel.DatabaseQuery_getArclinkRequestRestricted(self, userID, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type, netClass, restricted)

# Register DatabaseQuery in _datamodel:
_datamodel.DatabaseQuery_swigregister(DatabaseQuery)

class ConfigSyncMessage(seiscomp.core.Message):
    r"""Proxy of C++ Seiscomp::DataModel::ConfigSyncMessage 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 _datamodel.ConfigSyncMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ConfigSyncMessage_TypeInfo()

    def className(self):
        r"""className(ConfigSyncMessage self) -> char const *"""
        return _datamodel.ConfigSyncMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(ConfigSyncMessage self) -> RTTI"""
        return _datamodel.ConfigSyncMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ConfigSyncMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigSyncMessage
        """
        return _datamodel.ConfigSyncMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ConfigSyncMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigSyncMessage
        """
        return _datamodel.ConfigSyncMessage_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ConfigSyncMessage self, GenericArchive ar)"""
        return _datamodel.ConfigSyncMessage_serialize(self, ar)

    def __init__(self, *args):
        r"""
        __init__(ConfigSyncMessage self) -> ConfigSyncMessage
        __init__(ConfigSyncMessage self, bool finished) -> ConfigSyncMessage
        """
        _datamodel.ConfigSyncMessage_swiginit(self, _datamodel.new_ConfigSyncMessage(*args))

    def empty(self):
        r"""empty(ConfigSyncMessage self) -> bool"""
        return _datamodel.ConfigSyncMessage_empty(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(ConfigSyncMessage self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.ConfigSyncMessage_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(ConfigSyncMessage self) -> CreationInfo
        creationInfo(ConfigSyncMessage self) -> CreationInfo
        """
        return _datamodel.ConfigSyncMessage_creationInfo(self, *args)
    isFinished = property(_datamodel.ConfigSyncMessage_isFinished_get, _datamodel.ConfigSyncMessage_isFinished_set, doc=r"""isFinished : bool""")
    __swig_destroy__ = _datamodel.delete_ConfigSyncMessage

# Register ConfigSyncMessage in _datamodel:
_datamodel.ConfigSyncMessage_swigregister(ConfigSyncMessage)

def ConfigSyncMessage_ClassName():
    r"""ConfigSyncMessage_ClassName() -> char const *"""
    return _datamodel.ConfigSyncMessage_ClassName()

def ConfigSyncMessage_TypeInfo():
    r"""ConfigSyncMessage_TypeInfo() -> RTTI"""
    return _datamodel.ConfigSyncMessage_TypeInfo()

def ConfigSyncMessage_Cast(*args):
    r"""
    ConfigSyncMessage_Cast(BaseObject o) -> ConfigSyncMessage
    ConfigSyncMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigSyncMessage
    """
    return _datamodel.ConfigSyncMessage_Cast(*args)

def ConfigSyncMessage_ConstCast(*args):
    r"""
    ConfigSyncMessage_ConstCast(BaseObject o) -> ConfigSyncMessage
    ConfigSyncMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigSyncMessage
    """
    return _datamodel.ConfigSyncMessage_ConstCast(*args)

class InventorySyncMessage(seiscomp.core.Message):
    r"""Proxy of C++ Seiscomp::DataModel::InventorySyncMessage 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 _datamodel.InventorySyncMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.InventorySyncMessage_TypeInfo()

    def className(self):
        r"""className(InventorySyncMessage self) -> char const *"""
        return _datamodel.InventorySyncMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(InventorySyncMessage self) -> RTTI"""
        return _datamodel.InventorySyncMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> InventorySyncMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> InventorySyncMessage
        """
        return _datamodel.InventorySyncMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> InventorySyncMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> InventorySyncMessage
        """
        return _datamodel.InventorySyncMessage_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(InventorySyncMessage self, GenericArchive ar)"""
        return _datamodel.InventorySyncMessage_serialize(self, ar)

    def __init__(self, *args):
        r"""
        __init__(InventorySyncMessage self) -> InventorySyncMessage
        __init__(InventorySyncMessage self, bool finished) -> InventorySyncMessage
        """
        _datamodel.InventorySyncMessage_swiginit(self, _datamodel.new_InventorySyncMessage(*args))

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(InventorySyncMessage self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
        return _datamodel.InventorySyncMessage_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(InventorySyncMessage self) -> CreationInfo
        creationInfo(InventorySyncMessage self) -> CreationInfo
        """
        return _datamodel.InventorySyncMessage_creationInfo(self, *args)

    def empty(self):
        r"""empty(InventorySyncMessage self) -> bool"""
        return _datamodel.InventorySyncMessage_empty(self)
    isFinished = property(_datamodel.InventorySyncMessage_isFinished_get, _datamodel.InventorySyncMessage_isFinished_set, doc=r"""isFinished : bool""")
    __swig_destroy__ = _datamodel.delete_InventorySyncMessage

# Register InventorySyncMessage in _datamodel:
_datamodel.InventorySyncMessage_swigregister(InventorySyncMessage)

def InventorySyncMessage_ClassName():
    r"""InventorySyncMessage_ClassName() -> char const *"""
    return _datamodel.InventorySyncMessage_ClassName()

def InventorySyncMessage_TypeInfo():
    r"""InventorySyncMessage_TypeInfo() -> RTTI"""
    return _datamodel.InventorySyncMessage_TypeInfo()

def InventorySyncMessage_Cast(*args):
    r"""
    InventorySyncMessage_Cast(BaseObject o) -> InventorySyncMessage
    InventorySyncMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> InventorySyncMessage
    """
    return _datamodel.InventorySyncMessage_Cast(*args)

def InventorySyncMessage_ConstCast(*args):
    r"""
    InventorySyncMessage_ConstCast(BaseObject o) -> InventorySyncMessage
    InventorySyncMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> InventorySyncMessage
    """
    return _datamodel.InventorySyncMessage_ConstCast(*args)

class ArtificialOriginMessage(seiscomp.core.Message):
    r"""Proxy of C++ Seiscomp::DataModel::ArtificialOriginMessage 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 _datamodel.ArtificialOriginMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ArtificialOriginMessage_TypeInfo()

    def className(self):
        r"""className(ArtificialOriginMessage self) -> char const *"""
        return _datamodel.ArtificialOriginMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(ArtificialOriginMessage self) -> RTTI"""
        return _datamodel.ArtificialOriginMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArtificialOriginMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArtificialOriginMessage
        """
        return _datamodel.ArtificialOriginMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArtificialOriginMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArtificialOriginMessage
        """
        return _datamodel.ArtificialOriginMessage_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ArtificialOriginMessage self, GenericArchive ar)"""
        return _datamodel.ArtificialOriginMessage_serialize(self, ar)

    def __init__(self, origin):
        r"""__init__(ArtificialOriginMessage self, Origin origin) -> ArtificialOriginMessage"""
        _datamodel.ArtificialOriginMessage_swiginit(self, _datamodel.new_ArtificialOriginMessage(origin))

    def origin(self):
        r"""origin(ArtificialOriginMessage self) -> Origin"""
        return _datamodel.ArtificialOriginMessage_origin(self)

    def setOrigin(self, origin):
        r"""setOrigin(ArtificialOriginMessage self, Origin origin)"""
        return _datamodel.ArtificialOriginMessage_setOrigin(self, origin)

    def empty(self):
        r"""empty(ArtificialOriginMessage self) -> bool"""
        return _datamodel.ArtificialOriginMessage_empty(self)
    __swig_destroy__ = _datamodel.delete_ArtificialOriginMessage

# Register ArtificialOriginMessage in _datamodel:
_datamodel.ArtificialOriginMessage_swigregister(ArtificialOriginMessage)

def ArtificialOriginMessage_ClassName():
    r"""ArtificialOriginMessage_ClassName() -> char const *"""
    return _datamodel.ArtificialOriginMessage_ClassName()

def ArtificialOriginMessage_TypeInfo():
    r"""ArtificialOriginMessage_TypeInfo() -> RTTI"""
    return _datamodel.ArtificialOriginMessage_TypeInfo()

def ArtificialOriginMessage_Cast(*args):
    r"""
    ArtificialOriginMessage_Cast(BaseObject o) -> ArtificialOriginMessage
    ArtificialOriginMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArtificialOriginMessage
    """
    return _datamodel.ArtificialOriginMessage_Cast(*args)

def ArtificialOriginMessage_ConstCast(*args):
    r"""
    ArtificialOriginMessage_ConstCast(BaseObject o) -> ArtificialOriginMessage
    ArtificialOriginMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArtificialOriginMessage
    """
    return _datamodel.ArtificialOriginMessage_ConstCast(*args)

class ArtificialEventParametersMessage(seiscomp.core.Message):
    r"""Proxy of C++ Seiscomp::DataModel::ArtificialEventParametersMessage 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 _datamodel.ArtificialEventParametersMessage_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _datamodel.ArtificialEventParametersMessage_TypeInfo()

    def className(self):
        r"""className(ArtificialEventParametersMessage self) -> char const *"""
        return _datamodel.ArtificialEventParametersMessage_className(self)

    def typeInfo(self):
        r"""typeInfo(ArtificialEventParametersMessage self) -> RTTI"""
        return _datamodel.ArtificialEventParametersMessage_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArtificialEventParametersMessage
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArtificialEventParametersMessage
        """
        return _datamodel.ArtificialEventParametersMessage_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArtificialEventParametersMessage
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArtificialEventParametersMessage
        """
        return _datamodel.ArtificialEventParametersMessage_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(ArtificialEventParametersMessage self, GenericArchive ar)"""
        return _datamodel.ArtificialEventParametersMessage_serialize(self, ar)

    def __init__(self, eventParameters):
        r"""__init__(ArtificialEventParametersMessage self, EventParameters eventParameters) -> ArtificialEventParametersMessage"""
        _datamodel.ArtificialEventParametersMessage_swiginit(self, _datamodel.new_ArtificialEventParametersMessage(eventParameters))

    def eventParameters(self):
        r"""eventParameters(ArtificialEventParametersMessage self) -> EventParameters"""
        return _datamodel.ArtificialEventParametersMessage_eventParameters(self)

    def setEventParameters(self, eventParameters):
        r"""setEventParameters(ArtificialEventParametersMessage self, EventParameters eventParameters)"""
        return _datamodel.ArtificialEventParametersMessage_setEventParameters(self, eventParameters)

    def empty(self):
        r"""empty(ArtificialEventParametersMessage self) -> bool"""
        return _datamodel.ArtificialEventParametersMessage_empty(self)
    __swig_destroy__ = _datamodel.delete_ArtificialEventParametersMessage

# Register ArtificialEventParametersMessage in _datamodel:
_datamodel.ArtificialEventParametersMessage_swigregister(ArtificialEventParametersMessage)

def ArtificialEventParametersMessage_ClassName():
    r"""ArtificialEventParametersMessage_ClassName() -> char const *"""
    return _datamodel.ArtificialEventParametersMessage_ClassName()

def ArtificialEventParametersMessage_TypeInfo():
    r"""ArtificialEventParametersMessage_TypeInfo() -> RTTI"""
    return _datamodel.ArtificialEventParametersMessage_TypeInfo()

def ArtificialEventParametersMessage_Cast(*args):
    r"""
    ArtificialEventParametersMessage_Cast(BaseObject o) -> ArtificialEventParametersMessage
    ArtificialEventParametersMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArtificialEventParametersMessage
    """
    return _datamodel.ArtificialEventParametersMessage_Cast(*args)

def ArtificialEventParametersMessage_ConstCast(*args):
    r"""
    ArtificialEventParametersMessage_ConstCast(BaseObject o) -> ArtificialEventParametersMessage
    ArtificialEventParametersMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArtificialEventParametersMessage
    """
    return _datamodel.ArtificialEventParametersMessage_ConstCast(*args)

SEISCOMP_DATAMODEL_XMLNS_ROOT = _datamodel.SEISCOMP_DATAMODEL_XMLNS_ROOT

SEISCOMP_DATAMODEL_XMLNS = _datamodel.SEISCOMP_DATAMODEL_XMLNS

class Version(object):
    r"""Proxy of C++ Seiscomp::DataModel::Version class."""

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

    def __init__(self):
        r"""__init__(Version self) -> Version"""
        _datamodel.Version_swiginit(self, _datamodel.new_Version())
    __swig_destroy__ = _datamodel.delete_Version

# Register Version in _datamodel:
_datamodel.Version_swigregister(Version)


def QML_NS():
    r"""QML_NS() -> char const *"""
    return _datamodel.QML_NS()

def QML_NS_RT():
    r"""QML_NS_RT() -> char const *"""
    return _datamodel.QML_NS_RT()

def QML_NS_BED():
    r"""QML_NS_BED() -> char const *"""
    return _datamodel.QML_NS_BED()

def QML_NS_BED_RT():
    r"""QML_NS_BED_RT() -> char const *"""
    return _datamodel.QML_NS_BED_RT()

def QML_SMIPrefix():
    r"""QML_SMIPrefix() -> std::string const &"""
    return _datamodel.QML_SMIPrefix()
class QMLTypeMapper(object):
    r"""Proxy of C++ Seiscomp::QML::TypeMapper class."""

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

    @staticmethod
    def EventTypeFromString(str):
        r"""EventTypeFromString(std::string const & str) -> Seiscomp::DataModel::EventType"""
        return _datamodel.QMLTypeMapper_EventTypeFromString(str)

    @staticmethod
    def EventTypeToString(type):
        r"""EventTypeToString(Seiscomp::DataModel::EventType type) -> std::string"""
        return _datamodel.QMLTypeMapper_EventTypeToString(type)

    @staticmethod
    def EventTypeCertaintyToString(type):
        r"""EventTypeCertaintyToString(Seiscomp::DataModel::EventTypeCertainty type) -> std::string"""
        return _datamodel.QMLTypeMapper_EventTypeCertaintyToString(type)

    def __init__(self):
        r"""__init__(QMLTypeMapper self) -> QMLTypeMapper"""
        _datamodel.QMLTypeMapper_swiginit(self, _datamodel.new_QMLTypeMapper())
    __swig_destroy__ = _datamodel.delete_QMLTypeMapper

# Register QMLTypeMapper in _datamodel:
_datamodel.QMLTypeMapper_swigregister(QMLTypeMapper)
cvar = _datamodel.cvar
QML_SMIPrefixEnvVar = cvar.QML_SMIPrefixEnvVar

def QMLTypeMapper_EventTypeFromString(str):
    r"""QMLTypeMapper_EventTypeFromString(std::string const & str) -> Seiscomp::DataModel::EventType"""
    return _datamodel.QMLTypeMapper_EventTypeFromString(str)

def QMLTypeMapper_EventTypeToString(type):
    r"""QMLTypeMapper_EventTypeToString(Seiscomp::DataModel::EventType type) -> std::string"""
    return _datamodel.QMLTypeMapper_EventTypeToString(type)

def QMLTypeMapper_EventTypeCertaintyToString(type):
    r"""QMLTypeMapper_EventTypeCertaintyToString(Seiscomp::DataModel::EventTypeCertainty type) -> std::string"""
    return _datamodel.QMLTypeMapper_EventTypeCertaintyToString(type)