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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _strongmotion:
_strongmotion.SwigPyIterator_swigregister(SwigPyIterator)
import seiscomp.datamodel
import seiscomp.io
import seiscomp.math
import seiscomp.core
import seiscomp.geo
footwall = _strongmotion.footwall

hangingwall = _strongmotion.hangingwall

EFwHwIndicatorQuantity = _strongmotion.EFwHwIndicatorQuantity

class EFwHwIndicatorNames(object):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::EFwHwIndicatorNames 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__(EFwHwIndicatorNames self) -> EFwHwIndicatorNames"""
        _strongmotion.EFwHwIndicatorNames_swiginit(self, _strongmotion.new_EFwHwIndicatorNames())

    @staticmethod
    def name(i):
        r"""name(int i) -> char const *"""
        return _strongmotion.EFwHwIndicatorNames_name(i)
    __swig_destroy__ = _strongmotion.delete_EFwHwIndicatorNames

# Register EFwHwIndicatorNames in _strongmotion:
_strongmotion.EFwHwIndicatorNames_swigregister(EFwHwIndicatorNames)
class SimpleFilterChainMemberIndex(object):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::SimpleFilterChainMemberIndex 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__(SimpleFilterChainMemberIndex self) -> SimpleFilterChainMemberIndex
        __init__(SimpleFilterChainMemberIndex self, int sequenceNo) -> SimpleFilterChainMemberIndex
        __init__(SimpleFilterChainMemberIndex self, SimpleFilterChainMemberIndex arg2) -> SimpleFilterChainMemberIndex
        """
        _strongmotion.SimpleFilterChainMemberIndex_swiginit(self, _strongmotion.new_SimpleFilterChainMemberIndex(*args))

    def __eq__(self, arg2):
        r"""__eq__(SimpleFilterChainMemberIndex self, SimpleFilterChainMemberIndex arg2) -> bool"""
        return _strongmotion.SimpleFilterChainMemberIndex___eq__(self, arg2)

    def __ne__(self, arg2):
        r"""__ne__(SimpleFilterChainMemberIndex self, SimpleFilterChainMemberIndex arg2) -> bool"""
        return _strongmotion.SimpleFilterChainMemberIndex___ne__(self, arg2)
    sequenceNo = property(_strongmotion.SimpleFilterChainMemberIndex_sequenceNo_get, _strongmotion.SimpleFilterChainMemberIndex_sequenceNo_set, doc=r"""sequenceNo : int""")
    __swig_destroy__ = _strongmotion.delete_SimpleFilterChainMemberIndex

# Register SimpleFilterChainMemberIndex in _strongmotion:
_strongmotion.SimpleFilterChainMemberIndex_swigregister(SimpleFilterChainMemberIndex)
class SimpleFilterChainMember(seiscomp.datamodel.Object):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::SimpleFilterChainMember 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 _strongmotion.SimpleFilterChainMember_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.SimpleFilterChainMember_TypeInfo()

    def className(self):
        r"""className(SimpleFilterChainMember self) -> char const *"""
        return _strongmotion.SimpleFilterChainMember_className(self)

    def typeInfo(self):
        r"""typeInfo(SimpleFilterChainMember self) -> RTTI"""
        return _strongmotion.SimpleFilterChainMember_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> SimpleFilterChainMember
        Cast(Seiscomp::Core::BaseObjectPtr o) -> SimpleFilterChainMember
        """
        return _strongmotion.SimpleFilterChainMember_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> SimpleFilterChainMember
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SimpleFilterChainMember
        """
        return _strongmotion.SimpleFilterChainMember_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(SimpleFilterChainMember self, GenericArchive ar)"""
        return _strongmotion.SimpleFilterChainMember_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.SimpleFilterChainMember_Meta()

    def meta(self):
        r"""meta(SimpleFilterChainMember self) -> MetaObject"""
        return _strongmotion.SimpleFilterChainMember_meta(self)

    def __init__(self, *args):
        r"""
        __init__(SimpleFilterChainMember self) -> SimpleFilterChainMember
        __init__(SimpleFilterChainMember self, SimpleFilterChainMember other) -> SimpleFilterChainMember
        """
        _strongmotion.SimpleFilterChainMember_swiginit(self, _strongmotion.new_SimpleFilterChainMember(*args))
    __swig_destroy__ = _strongmotion.delete_SimpleFilterChainMember

    def __eq__(self, other):
        r"""__eq__(SimpleFilterChainMember self, SimpleFilterChainMember other) -> bool"""
        return _strongmotion.SimpleFilterChainMember___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(SimpleFilterChainMember self, SimpleFilterChainMember other) -> bool"""
        return _strongmotion.SimpleFilterChainMember___ne__(self, other)

    def equal(self, other):
        r"""equal(SimpleFilterChainMember self, SimpleFilterChainMember other) -> bool"""
        return _strongmotion.SimpleFilterChainMember_equal(self, other)

    def setSequenceNo(self, sequenceNo):
        r"""setSequenceNo(SimpleFilterChainMember self, int sequenceNo)"""
        return _strongmotion.SimpleFilterChainMember_setSequenceNo(self, sequenceNo)

    def sequenceNo(self):
        r"""sequenceNo(SimpleFilterChainMember self) -> int"""
        return _strongmotion.SimpleFilterChainMember_sequenceNo(self)

    def setSimpleFilterID(self, simpleFilterID):
        r"""setSimpleFilterID(SimpleFilterChainMember self, std::string const & simpleFilterID)"""
        return _strongmotion.SimpleFilterChainMember_setSimpleFilterID(self, simpleFilterID)

    def simpleFilterID(self):
        r"""simpleFilterID(SimpleFilterChainMember self) -> std::string const &"""
        return _strongmotion.SimpleFilterChainMember_simpleFilterID(self)

    def index(self):
        r"""index(SimpleFilterChainMember self) -> SimpleFilterChainMemberIndex"""
        return _strongmotion.SimpleFilterChainMember_index(self)

    def equalIndex(self, lhs):
        r"""equalIndex(SimpleFilterChainMember self, SimpleFilterChainMember lhs) -> bool"""
        return _strongmotion.SimpleFilterChainMember_equalIndex(self, lhs)

    def record(self):
        r"""record(SimpleFilterChainMember self) -> Record"""
        return _strongmotion.SimpleFilterChainMember_record(self)

    def assign(self, other):
        r"""assign(SimpleFilterChainMember self, Object other) -> bool"""
        return _strongmotion.SimpleFilterChainMember_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(SimpleFilterChainMember self, PublicObject parent) -> bool"""
        return _strongmotion.SimpleFilterChainMember_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(SimpleFilterChainMember self, PublicObject parent) -> bool"""
        return _strongmotion.SimpleFilterChainMember_detachFrom(self, parent)

    def detach(self):
        r"""detach(SimpleFilterChainMember self) -> bool"""
        return _strongmotion.SimpleFilterChainMember_detach(self)

    def clone(self):
        r"""clone(SimpleFilterChainMember self) -> Object"""
        return _strongmotion.SimpleFilterChainMember_clone(self)

    def accept(self, arg2):
        r"""accept(SimpleFilterChainMember self, Visitor arg2)"""
        return _strongmotion.SimpleFilterChainMember_accept(self, arg2)

# Register SimpleFilterChainMember in _strongmotion:
_strongmotion.SimpleFilterChainMember_swigregister(SimpleFilterChainMember)
class SimpleFilter(seiscomp.datamodel.PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::SimpleFilter 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 _strongmotion.SimpleFilter_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.SimpleFilter_TypeInfo()

    def className(self):
        r"""className(SimpleFilter self) -> char const *"""
        return _strongmotion.SimpleFilter_className(self)

    def typeInfo(self):
        r"""typeInfo(SimpleFilter self) -> RTTI"""
        return _strongmotion.SimpleFilter_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> SimpleFilter
        Cast(Seiscomp::Core::BaseObjectPtr o) -> SimpleFilter
        """
        return _strongmotion.SimpleFilter_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> SimpleFilter
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SimpleFilter
        """
        return _strongmotion.SimpleFilter_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(SimpleFilter self, GenericArchive ar)"""
        return _strongmotion.SimpleFilter_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.SimpleFilter_Meta()

    def meta(self):
        r"""meta(SimpleFilter self) -> MetaObject"""
        return _strongmotion.SimpleFilter_meta(self)

    def __init__(self, *args):
        r"""
        __init__(SimpleFilter self, SimpleFilter other) -> SimpleFilter
        __init__(SimpleFilter self, std::string const & publicID) -> SimpleFilter
        """
        _strongmotion.SimpleFilter_swiginit(self, _strongmotion.new_SimpleFilter(*args))
    __swig_destroy__ = _strongmotion.delete_SimpleFilter

    @staticmethod
    def Create(*args):
        r"""
        Create() -> SimpleFilter
        Create(std::string const & publicID) -> SimpleFilter
        """
        return _strongmotion.SimpleFilter_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> SimpleFilter"""
        return _strongmotion.SimpleFilter_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(SimpleFilter self, SimpleFilter other) -> bool"""
        return _strongmotion.SimpleFilter___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(SimpleFilter self, SimpleFilter other) -> bool"""
        return _strongmotion.SimpleFilter___ne__(self, other)

    def equal(self, other):
        r"""equal(SimpleFilter self, SimpleFilter other) -> bool"""
        return _strongmotion.SimpleFilter_equal(self, other)

    def setType(self, type):
        r"""setType(SimpleFilter self, std::string const & type)"""
        return _strongmotion.SimpleFilter_setType(self, type)

    def type(self):
        r"""type(SimpleFilter self) -> std::string const &"""
        return _strongmotion.SimpleFilter_type(self)

    def add(self, obj):
        r"""add(SimpleFilter self, FilterParameter obj) -> bool"""
        return _strongmotion.SimpleFilter_add(self, obj)

    def remove(self, obj):
        r"""remove(SimpleFilter self, FilterParameter obj) -> bool"""
        return _strongmotion.SimpleFilter_remove(self, obj)

    def removeFilterParameter(self, i):
        r"""removeFilterParameter(SimpleFilter self, size_t i) -> bool"""
        return _strongmotion.SimpleFilter_removeFilterParameter(self, i)

    def filterParameterCount(self):
        r"""filterParameterCount(SimpleFilter self) -> size_t"""
        return _strongmotion.SimpleFilter_filterParameterCount(self)

    def filterParameter(self, i):
        r"""filterParameter(SimpleFilter self, size_t i) -> FilterParameter"""
        return _strongmotion.SimpleFilter_filterParameter(self, i)

    def findFilterParameter(self, filterParameter):
        r"""findFilterParameter(SimpleFilter self, FilterParameter filterParameter) -> FilterParameter"""
        return _strongmotion.SimpleFilter_findFilterParameter(self, filterParameter)

    def strongMotionParameters(self):
        r"""strongMotionParameters(SimpleFilter self) -> StrongMotionParameters"""
        return _strongmotion.SimpleFilter_strongMotionParameters(self)

    def assign(self, other):
        r"""assign(SimpleFilter self, Object other) -> bool"""
        return _strongmotion.SimpleFilter_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(SimpleFilter self, PublicObject parent) -> bool"""
        return _strongmotion.SimpleFilter_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(SimpleFilter self, PublicObject parent) -> bool"""
        return _strongmotion.SimpleFilter_detachFrom(self, parent)

    def detach(self):
        r"""detach(SimpleFilter self) -> bool"""
        return _strongmotion.SimpleFilter_detach(self)

    def clone(self):
        r"""clone(SimpleFilter self) -> Object"""
        return _strongmotion.SimpleFilter_clone(self)

    def updateChild(self, child):
        r"""updateChild(SimpleFilter self, Object child) -> bool"""
        return _strongmotion.SimpleFilter_updateChild(self, child)

    def accept(self, arg2):
        r"""accept(SimpleFilter self, Visitor arg2)"""
        return _strongmotion.SimpleFilter_accept(self, arg2)

# Register SimpleFilter in _strongmotion:
_strongmotion.SimpleFilter_swigregister(SimpleFilter)
class Contact(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::Contact 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 _strongmotion.Contact_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.Contact_TypeInfo()

    def className(self):
        r"""className(Contact self) -> char const *"""
        return _strongmotion.Contact_className(self)

    def typeInfo(self):
        r"""typeInfo(Contact self) -> RTTI"""
        return _strongmotion.Contact_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Contact
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Contact
        """
        return _strongmotion.Contact_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Contact
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Contact
        """
        return _strongmotion.Contact_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Contact self, GenericArchive ar)"""
        return _strongmotion.Contact_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.Contact_Meta()

    def meta(self):
        r"""meta(Contact self) -> MetaObject"""
        return _strongmotion.Contact_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Contact self) -> Contact
        __init__(Contact self, Contact other) -> Contact
        """
        _strongmotion.Contact_swiginit(self, _strongmotion.new_Contact(*args))
    __swig_destroy__ = _strongmotion.delete_Contact

    def __eq__(self, other):
        r"""__eq__(Contact self, Contact other) -> bool"""
        return _strongmotion.Contact___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Contact self, Contact other) -> bool"""
        return _strongmotion.Contact___ne__(self, other)

    def equal(self, other):
        r"""equal(Contact self, Contact other) -> bool"""
        return _strongmotion.Contact_equal(self, other)

    def setName(self, name):
        r"""setName(Contact self, std::string const & name)"""
        return _strongmotion.Contact_setName(self, name)

    def name(self):
        r"""name(Contact self) -> std::string const &"""
        return _strongmotion.Contact_name(self)

    def setForename(self, forename):
        r"""setForename(Contact self, std::string const & forename)"""
        return _strongmotion.Contact_setForename(self, forename)

    def forename(self):
        r"""forename(Contact self) -> std::string const &"""
        return _strongmotion.Contact_forename(self)

    def setAgency(self, agency):
        r"""setAgency(Contact self, std::string const & agency)"""
        return _strongmotion.Contact_setAgency(self, agency)

    def agency(self):
        r"""agency(Contact self) -> std::string const &"""
        return _strongmotion.Contact_agency(self)

    def setDepartment(self, department):
        r"""setDepartment(Contact self, std::string const & department)"""
        return _strongmotion.Contact_setDepartment(self, department)

    def department(self):
        r"""department(Contact self) -> std::string const &"""
        return _strongmotion.Contact_department(self)

    def setAddress(self, address):
        r"""setAddress(Contact self, std::string const & address)"""
        return _strongmotion.Contact_setAddress(self, address)

    def address(self):
        r"""address(Contact self) -> std::string const &"""
        return _strongmotion.Contact_address(self)

    def setPhone(self, phone):
        r"""setPhone(Contact self, std::string const & phone)"""
        return _strongmotion.Contact_setPhone(self, phone)

    def phone(self):
        r"""phone(Contact self) -> std::string const &"""
        return _strongmotion.Contact_phone(self)

    def setEmail(self, email):
        r"""setEmail(Contact self, std::string const & email)"""
        return _strongmotion.Contact_setEmail(self, email)

    def email(self):
        r"""email(Contact self) -> std::string const &"""
        return _strongmotion.Contact_email(self)

# Register Contact in _strongmotion:
_strongmotion.Contact_swigregister(Contact)
class EventRecordReference(seiscomp.datamodel.Object):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::EventRecordReference 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 _strongmotion.EventRecordReference_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.EventRecordReference_TypeInfo()

    def className(self):
        r"""className(EventRecordReference self) -> char const *"""
        return _strongmotion.EventRecordReference_className(self)

    def typeInfo(self):
        r"""typeInfo(EventRecordReference self) -> RTTI"""
        return _strongmotion.EventRecordReference_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> EventRecordReference
        Cast(Seiscomp::Core::BaseObjectPtr o) -> EventRecordReference
        """
        return _strongmotion.EventRecordReference_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> EventRecordReference
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventRecordReference
        """
        return _strongmotion.EventRecordReference_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(EventRecordReference self, GenericArchive ar)"""
        return _strongmotion.EventRecordReference_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.EventRecordReference_Meta()

    def meta(self):
        r"""meta(EventRecordReference self) -> MetaObject"""
        return _strongmotion.EventRecordReference_meta(self)

    def __init__(self, *args):
        r"""
        __init__(EventRecordReference self) -> EventRecordReference
        __init__(EventRecordReference self, EventRecordReference other) -> EventRecordReference
        __init__(EventRecordReference self, std::string const & recordID) -> EventRecordReference
        __init__(EventRecordReference self, std::string const & recordID, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & campbellDistance, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & ruptureToStationAzimuth, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & ruptureAreaDistance, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & JoynerBooreDistance, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & closestFaultDistance, Seiscomp::Core::Optional< double > const & preEventLength, Seiscomp::Core::Optional< double > const & postEventLength) -> EventRecordReference
        """
        _strongmotion.EventRecordReference_swiginit(self, _strongmotion.new_EventRecordReference(*args))
    __swig_destroy__ = _strongmotion.delete_EventRecordReference

    def __eq__(self, other):
        r"""__eq__(EventRecordReference self, EventRecordReference other) -> bool"""
        return _strongmotion.EventRecordReference___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(EventRecordReference self, EventRecordReference other) -> bool"""
        return _strongmotion.EventRecordReference___ne__(self, other)

    def equal(self, other):
        r"""equal(EventRecordReference self, EventRecordReference other) -> bool"""
        return _strongmotion.EventRecordReference_equal(self, other)

    def setRecordID(self, recordID):
        r"""setRecordID(EventRecordReference self, std::string const & recordID)"""
        return _strongmotion.EventRecordReference_setRecordID(self, recordID)

    def recordID(self):
        r"""recordID(EventRecordReference self) -> std::string const &"""
        return _strongmotion.EventRecordReference_recordID(self)

    def setCampbellDistance(self, campbellDistance):
        r"""setCampbellDistance(EventRecordReference self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & campbellDistance)"""
        return _strongmotion.EventRecordReference_setCampbellDistance(self, campbellDistance)

    def campbellDistance(self, *args):
        r"""
        campbellDistance(EventRecordReference self) -> RealQuantity
        campbellDistance(EventRecordReference self) -> RealQuantity
        """
        return _strongmotion.EventRecordReference_campbellDistance(self, *args)

    def setRuptureToStationAzimuth(self, ruptureToStationAzimuth):
        r"""setRuptureToStationAzimuth(EventRecordReference self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & ruptureToStationAzimuth)"""
        return _strongmotion.EventRecordReference_setRuptureToStationAzimuth(self, ruptureToStationAzimuth)

    def ruptureToStationAzimuth(self, *args):
        r"""
        ruptureToStationAzimuth(EventRecordReference self) -> RealQuantity
        ruptureToStationAzimuth(EventRecordReference self) -> RealQuantity
        """
        return _strongmotion.EventRecordReference_ruptureToStationAzimuth(self, *args)

    def setRuptureAreaDistance(self, ruptureAreaDistance):
        r"""setRuptureAreaDistance(EventRecordReference self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & ruptureAreaDistance)"""
        return _strongmotion.EventRecordReference_setRuptureAreaDistance(self, ruptureAreaDistance)

    def ruptureAreaDistance(self, *args):
        r"""
        ruptureAreaDistance(EventRecordReference self) -> RealQuantity
        ruptureAreaDistance(EventRecordReference self) -> RealQuantity
        """
        return _strongmotion.EventRecordReference_ruptureAreaDistance(self, *args)

    def setJoynerBooreDistance(self, JoynerBooreDistance):
        r"""setJoynerBooreDistance(EventRecordReference self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & JoynerBooreDistance)"""
        return _strongmotion.EventRecordReference_setJoynerBooreDistance(self, JoynerBooreDistance)

    def JoynerBooreDistance(self, *args):
        r"""
        JoynerBooreDistance(EventRecordReference self) -> RealQuantity
        JoynerBooreDistance(EventRecordReference self) -> RealQuantity
        """
        return _strongmotion.EventRecordReference_JoynerBooreDistance(self, *args)

    def setClosestFaultDistance(self, closestFaultDistance):
        r"""setClosestFaultDistance(EventRecordReference self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & closestFaultDistance)"""
        return _strongmotion.EventRecordReference_setClosestFaultDistance(self, closestFaultDistance)

    def closestFaultDistance(self, *args):
        r"""
        closestFaultDistance(EventRecordReference self) -> RealQuantity
        closestFaultDistance(EventRecordReference self) -> RealQuantity
        """
        return _strongmotion.EventRecordReference_closestFaultDistance(self, *args)

    def setPreEventLength(self, preEventLength):
        r"""setPreEventLength(EventRecordReference self, Seiscomp::Core::Optional< double > const & preEventLength)"""
        return _strongmotion.EventRecordReference_setPreEventLength(self, preEventLength)

    def preEventLength(self):
        r"""preEventLength(EventRecordReference self) -> double"""
        return _strongmotion.EventRecordReference_preEventLength(self)

    def setPostEventLength(self, postEventLength):
        r"""setPostEventLength(EventRecordReference self, Seiscomp::Core::Optional< double > const & postEventLength)"""
        return _strongmotion.EventRecordReference_setPostEventLength(self, postEventLength)

    def postEventLength(self):
        r"""postEventLength(EventRecordReference self) -> double"""
        return _strongmotion.EventRecordReference_postEventLength(self)

    def strongOriginDescription(self):
        r"""strongOriginDescription(EventRecordReference self) -> StrongOriginDescription"""
        return _strongmotion.EventRecordReference_strongOriginDescription(self)

    def assign(self, other):
        r"""assign(EventRecordReference self, Object other) -> bool"""
        return _strongmotion.EventRecordReference_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(EventRecordReference self, PublicObject parent) -> bool"""
        return _strongmotion.EventRecordReference_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(EventRecordReference self, PublicObject parent) -> bool"""
        return _strongmotion.EventRecordReference_detachFrom(self, parent)

    def detach(self):
        r"""detach(EventRecordReference self) -> bool"""
        return _strongmotion.EventRecordReference_detach(self)

    def clone(self):
        r"""clone(EventRecordReference self) -> Object"""
        return _strongmotion.EventRecordReference_clone(self)

    def accept(self, arg2):
        r"""accept(EventRecordReference self, Visitor arg2)"""
        return _strongmotion.EventRecordReference_accept(self, arg2)

# Register EventRecordReference in _strongmotion:
_strongmotion.EventRecordReference_swigregister(EventRecordReference)
class FileResource(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::FileResource 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 _strongmotion.FileResource_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.FileResource_TypeInfo()

    def className(self):
        r"""className(FileResource self) -> char const *"""
        return _strongmotion.FileResource_className(self)

    def typeInfo(self):
        r"""typeInfo(FileResource self) -> RTTI"""
        return _strongmotion.FileResource_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> FileResource
        Cast(Seiscomp::Core::BaseObjectPtr o) -> FileResource
        """
        return _strongmotion.FileResource_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> FileResource
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FileResource
        """
        return _strongmotion.FileResource_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(FileResource self, GenericArchive ar)"""
        return _strongmotion.FileResource_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.FileResource_Meta()

    def meta(self):
        r"""meta(FileResource self) -> MetaObject"""
        return _strongmotion.FileResource_meta(self)

    def __init__(self, *args):
        r"""
        __init__(FileResource self) -> FileResource
        __init__(FileResource self, FileResource other) -> FileResource
        """
        _strongmotion.FileResource_swiginit(self, _strongmotion.new_FileResource(*args))
    __swig_destroy__ = _strongmotion.delete_FileResource

    def __eq__(self, other):
        r"""__eq__(FileResource self, FileResource other) -> bool"""
        return _strongmotion.FileResource___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(FileResource self, FileResource other) -> bool"""
        return _strongmotion.FileResource___ne__(self, other)

    def equal(self, other):
        r"""equal(FileResource self, FileResource other) -> bool"""
        return _strongmotion.FileResource_equal(self, other)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(FileResource self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo > const & creationInfo)"""
        return _strongmotion.FileResource_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(FileResource self) -> CreationInfo
        creationInfo(FileResource self) -> CreationInfo
        """
        return _strongmotion.FileResource_creationInfo(self, *args)

    def setClass(self, Class):
        r"""setClass(FileResource self, std::string const & Class)"""
        return _strongmotion.FileResource_setClass(self, Class)

    def Class(self):
        r"""Class(FileResource self) -> std::string const &"""
        return _strongmotion.FileResource_Class(self)

    def setType(self, type):
        r"""setType(FileResource self, std::string const & type)"""
        return _strongmotion.FileResource_setType(self, type)

    def type(self):
        r"""type(FileResource self) -> std::string const &"""
        return _strongmotion.FileResource_type(self)

    def setFilename(self, filename):
        r"""setFilename(FileResource self, std::string const & filename)"""
        return _strongmotion.FileResource_setFilename(self, filename)

    def filename(self):
        r"""filename(FileResource self) -> std::string const &"""
        return _strongmotion.FileResource_filename(self)

    def setUrl(self, url):
        r"""setUrl(FileResource self, std::string const & url)"""
        return _strongmotion.FileResource_setUrl(self, url)

    def url(self):
        r"""url(FileResource self) -> std::string const &"""
        return _strongmotion.FileResource_url(self)

    def setDescription(self, description):
        r"""setDescription(FileResource self, std::string const & description)"""
        return _strongmotion.FileResource_setDescription(self, description)

    def description(self):
        r"""description(FileResource self) -> std::string const &"""
        return _strongmotion.FileResource_description(self)

# Register FileResource in _strongmotion:
_strongmotion.FileResource_swigregister(FileResource)
class FilterParameter(seiscomp.datamodel.Object):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::FilterParameter 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 _strongmotion.FilterParameter_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.FilterParameter_TypeInfo()

    def className(self):
        r"""className(FilterParameter self) -> char const *"""
        return _strongmotion.FilterParameter_className(self)

    def typeInfo(self):
        r"""typeInfo(FilterParameter self) -> RTTI"""
        return _strongmotion.FilterParameter_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> FilterParameter
        Cast(Seiscomp::Core::BaseObjectPtr o) -> FilterParameter
        """
        return _strongmotion.FilterParameter_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> FilterParameter
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FilterParameter
        """
        return _strongmotion.FilterParameter_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(FilterParameter self, GenericArchive ar)"""
        return _strongmotion.FilterParameter_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.FilterParameter_Meta()

    def meta(self):
        r"""meta(FilterParameter self) -> MetaObject"""
        return _strongmotion.FilterParameter_meta(self)

    def __init__(self, *args):
        r"""
        __init__(FilterParameter self) -> FilterParameter
        __init__(FilterParameter self, FilterParameter other) -> FilterParameter
        """
        _strongmotion.FilterParameter_swiginit(self, _strongmotion.new_FilterParameter(*args))
    __swig_destroy__ = _strongmotion.delete_FilterParameter

    def __eq__(self, other):
        r"""__eq__(FilterParameter self, FilterParameter other) -> bool"""
        return _strongmotion.FilterParameter___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(FilterParameter self, FilterParameter other) -> bool"""
        return _strongmotion.FilterParameter___ne__(self, other)

    def equal(self, other):
        r"""equal(FilterParameter self, FilterParameter other) -> bool"""
        return _strongmotion.FilterParameter_equal(self, other)

    def setValue(self, value):
        r"""setValue(FilterParameter self, RealQuantity value)"""
        return _strongmotion.FilterParameter_setValue(self, value)

    def value(self, *args):
        r"""
        value(FilterParameter self) -> RealQuantity
        value(FilterParameter self) -> RealQuantity
        """
        return _strongmotion.FilterParameter_value(self, *args)

    def setName(self, name):
        r"""setName(FilterParameter self, std::string const & name)"""
        return _strongmotion.FilterParameter_setName(self, name)

    def name(self):
        r"""name(FilterParameter self) -> std::string const &"""
        return _strongmotion.FilterParameter_name(self)

    def simpleFilter(self):
        r"""simpleFilter(FilterParameter self) -> SimpleFilter"""
        return _strongmotion.FilterParameter_simpleFilter(self)

    def assign(self, other):
        r"""assign(FilterParameter self, Object other) -> bool"""
        return _strongmotion.FilterParameter_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(FilterParameter self, PublicObject parent) -> bool"""
        return _strongmotion.FilterParameter_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(FilterParameter self, PublicObject parent) -> bool"""
        return _strongmotion.FilterParameter_detachFrom(self, parent)

    def detach(self):
        r"""detach(FilterParameter self) -> bool"""
        return _strongmotion.FilterParameter_detach(self)

    def clone(self):
        r"""clone(FilterParameter self) -> Object"""
        return _strongmotion.FilterParameter_clone(self)

    def accept(self, arg2):
        r"""accept(FilterParameter self, Visitor arg2)"""
        return _strongmotion.FilterParameter_accept(self, arg2)

# Register FilterParameter in _strongmotion:
_strongmotion.FilterParameter_swigregister(FilterParameter)
class LiteratureSource(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::LiteratureSource 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 _strongmotion.LiteratureSource_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.LiteratureSource_TypeInfo()

    def className(self):
        r"""className(LiteratureSource self) -> char const *"""
        return _strongmotion.LiteratureSource_className(self)

    def typeInfo(self):
        r"""typeInfo(LiteratureSource self) -> RTTI"""
        return _strongmotion.LiteratureSource_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> LiteratureSource
        Cast(Seiscomp::Core::BaseObjectPtr o) -> LiteratureSource
        """
        return _strongmotion.LiteratureSource_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> LiteratureSource
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> LiteratureSource
        """
        return _strongmotion.LiteratureSource_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(LiteratureSource self, GenericArchive ar)"""
        return _strongmotion.LiteratureSource_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.LiteratureSource_Meta()

    def meta(self):
        r"""meta(LiteratureSource self) -> MetaObject"""
        return _strongmotion.LiteratureSource_meta(self)

    def __init__(self, *args):
        r"""
        __init__(LiteratureSource self) -> LiteratureSource
        __init__(LiteratureSource self, LiteratureSource other) -> LiteratureSource
        __init__(LiteratureSource self, std::string const & title) -> LiteratureSource
        __init__(LiteratureSource self, std::string const & title, std::string const & firstAuthorName, std::string const & firstAuthorForename, std::string const & secondaryAuthors, std::string const & doi, Seiscomp::Core::Optional< int > const & year, std::string const & in_title, std::string const & editor, std::string const & place, std::string const & language, Seiscomp::Core::Optional< int > const & tome, Seiscomp::Core::Optional< int > const & page_from, Seiscomp::Core::Optional< int > const & page_to) -> LiteratureSource
        """
        _strongmotion.LiteratureSource_swiginit(self, _strongmotion.new_LiteratureSource(*args))
    __swig_destroy__ = _strongmotion.delete_LiteratureSource

    def __eq__(self, other):
        r"""__eq__(LiteratureSource self, LiteratureSource other) -> bool"""
        return _strongmotion.LiteratureSource___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(LiteratureSource self, LiteratureSource other) -> bool"""
        return _strongmotion.LiteratureSource___ne__(self, other)

    def equal(self, other):
        r"""equal(LiteratureSource self, LiteratureSource other) -> bool"""
        return _strongmotion.LiteratureSource_equal(self, other)

    def setTitle(self, title):
        r"""setTitle(LiteratureSource self, std::string const & title)"""
        return _strongmotion.LiteratureSource_setTitle(self, title)

    def title(self):
        r"""title(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_title(self)

    def setFirstAuthorName(self, firstAuthorName):
        r"""setFirstAuthorName(LiteratureSource self, std::string const & firstAuthorName)"""
        return _strongmotion.LiteratureSource_setFirstAuthorName(self, firstAuthorName)

    def firstAuthorName(self):
        r"""firstAuthorName(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_firstAuthorName(self)

    def setFirstAuthorForename(self, firstAuthorForename):
        r"""setFirstAuthorForename(LiteratureSource self, std::string const & firstAuthorForename)"""
        return _strongmotion.LiteratureSource_setFirstAuthorForename(self, firstAuthorForename)

    def firstAuthorForename(self):
        r"""firstAuthorForename(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_firstAuthorForename(self)

    def setSecondaryAuthors(self, secondaryAuthors):
        r"""setSecondaryAuthors(LiteratureSource self, std::string const & secondaryAuthors)"""
        return _strongmotion.LiteratureSource_setSecondaryAuthors(self, secondaryAuthors)

    def secondaryAuthors(self):
        r"""secondaryAuthors(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_secondaryAuthors(self)

    def setDoi(self, doi):
        r"""setDoi(LiteratureSource self, std::string const & doi)"""
        return _strongmotion.LiteratureSource_setDoi(self, doi)

    def doi(self):
        r"""doi(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_doi(self)

    def setYear(self, year):
        r"""setYear(LiteratureSource self, Seiscomp::Core::Optional< int > const & year)"""
        return _strongmotion.LiteratureSource_setYear(self, year)

    def year(self):
        r"""year(LiteratureSource self) -> int"""
        return _strongmotion.LiteratureSource_year(self)

    def setInTitle(self, inTitle):
        r"""setInTitle(LiteratureSource self, std::string const & inTitle)"""
        return _strongmotion.LiteratureSource_setInTitle(self, inTitle)

    def inTitle(self):
        r"""inTitle(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_inTitle(self)

    def setEditor(self, editor):
        r"""setEditor(LiteratureSource self, std::string const & editor)"""
        return _strongmotion.LiteratureSource_setEditor(self, editor)

    def editor(self):
        r"""editor(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_editor(self)

    def setPlace(self, place):
        r"""setPlace(LiteratureSource self, std::string const & place)"""
        return _strongmotion.LiteratureSource_setPlace(self, place)

    def place(self):
        r"""place(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_place(self)

    def setLanguage(self, language):
        r"""setLanguage(LiteratureSource self, std::string const & language)"""
        return _strongmotion.LiteratureSource_setLanguage(self, language)

    def language(self):
        r"""language(LiteratureSource self) -> std::string const &"""
        return _strongmotion.LiteratureSource_language(self)

    def setTome(self, tome):
        r"""setTome(LiteratureSource self, Seiscomp::Core::Optional< int > const & tome)"""
        return _strongmotion.LiteratureSource_setTome(self, tome)

    def tome(self):
        r"""tome(LiteratureSource self) -> int"""
        return _strongmotion.LiteratureSource_tome(self)

    def setPageFrom(self, pageFrom):
        r"""setPageFrom(LiteratureSource self, Seiscomp::Core::Optional< int > const & pageFrom)"""
        return _strongmotion.LiteratureSource_setPageFrom(self, pageFrom)

    def pageFrom(self):
        r"""pageFrom(LiteratureSource self) -> int"""
        return _strongmotion.LiteratureSource_pageFrom(self)

    def setPageTo(self, pageTo):
        r"""setPageTo(LiteratureSource self, Seiscomp::Core::Optional< int > const & pageTo)"""
        return _strongmotion.LiteratureSource_setPageTo(self, pageTo)

    def pageTo(self):
        r"""pageTo(LiteratureSource self) -> int"""
        return _strongmotion.LiteratureSource_pageTo(self)

# Register LiteratureSource in _strongmotion:
_strongmotion.LiteratureSource_swigregister(LiteratureSource)
class SurfaceRupture(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::SurfaceRupture 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 _strongmotion.SurfaceRupture_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.SurfaceRupture_TypeInfo()

    def className(self):
        r"""className(SurfaceRupture self) -> char const *"""
        return _strongmotion.SurfaceRupture_className(self)

    def typeInfo(self):
        r"""typeInfo(SurfaceRupture self) -> RTTI"""
        return _strongmotion.SurfaceRupture_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> SurfaceRupture
        Cast(Seiscomp::Core::BaseObjectPtr o) -> SurfaceRupture
        """
        return _strongmotion.SurfaceRupture_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> SurfaceRupture
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SurfaceRupture
        """
        return _strongmotion.SurfaceRupture_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(SurfaceRupture self, GenericArchive ar)"""
        return _strongmotion.SurfaceRupture_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.SurfaceRupture_Meta()

    def meta(self):
        r"""meta(SurfaceRupture self) -> MetaObject"""
        return _strongmotion.SurfaceRupture_meta(self)

    def __init__(self, *args):
        r"""
        __init__(SurfaceRupture self) -> SurfaceRupture
        __init__(SurfaceRupture self, SurfaceRupture other) -> SurfaceRupture
        """
        _strongmotion.SurfaceRupture_swiginit(self, _strongmotion.new_SurfaceRupture(*args))
    __swig_destroy__ = _strongmotion.delete_SurfaceRupture

    def __eq__(self, other):
        r"""__eq__(SurfaceRupture self, SurfaceRupture other) -> bool"""
        return _strongmotion.SurfaceRupture___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(SurfaceRupture self, SurfaceRupture other) -> bool"""
        return _strongmotion.SurfaceRupture___ne__(self, other)

    def equal(self, other):
        r"""equal(SurfaceRupture self, SurfaceRupture other) -> bool"""
        return _strongmotion.SurfaceRupture_equal(self, other)

    def setObserved(self, observed):
        r"""setObserved(SurfaceRupture self, bool observed)"""
        return _strongmotion.SurfaceRupture_setObserved(self, observed)

    def observed(self):
        r"""observed(SurfaceRupture self) -> bool"""
        return _strongmotion.SurfaceRupture_observed(self)

    def setEvidence(self, evidence):
        r"""setEvidence(SurfaceRupture self, std::string const & evidence)"""
        return _strongmotion.SurfaceRupture_setEvidence(self, evidence)

    def evidence(self):
        r"""evidence(SurfaceRupture self) -> std::string const &"""
        return _strongmotion.SurfaceRupture_evidence(self)

    def setLiteratureSource(self, literatureSource):
        r"""setLiteratureSource(SurfaceRupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::StrongMotion::LiteratureSource > const & literatureSource)"""
        return _strongmotion.SurfaceRupture_setLiteratureSource(self, literatureSource)

    def literatureSource(self, *args):
        r"""
        literatureSource(SurfaceRupture self) -> LiteratureSource
        literatureSource(SurfaceRupture self) -> LiteratureSource
        """
        return _strongmotion.SurfaceRupture_literatureSource(self, *args)

# Register SurfaceRupture in _strongmotion:
_strongmotion.SurfaceRupture_swigregister(SurfaceRupture)
class PeakMotion(seiscomp.datamodel.Object):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::PeakMotion 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 _strongmotion.PeakMotion_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.PeakMotion_TypeInfo()

    def className(self):
        r"""className(PeakMotion self) -> char const *"""
        return _strongmotion.PeakMotion_className(self)

    def typeInfo(self):
        r"""typeInfo(PeakMotion self) -> RTTI"""
        return _strongmotion.PeakMotion_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> PeakMotion
        Cast(Seiscomp::Core::BaseObjectPtr o) -> PeakMotion
        """
        return _strongmotion.PeakMotion_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> PeakMotion
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PeakMotion
        """
        return _strongmotion.PeakMotion_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(PeakMotion self, GenericArchive ar)"""
        return _strongmotion.PeakMotion_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.PeakMotion_Meta()

    def meta(self):
        r"""meta(PeakMotion self) -> MetaObject"""
        return _strongmotion.PeakMotion_meta(self)

    def __init__(self, *args):
        r"""
        __init__(PeakMotion self) -> PeakMotion
        __init__(PeakMotion self, PeakMotion other) -> PeakMotion
        """
        _strongmotion.PeakMotion_swiginit(self, _strongmotion.new_PeakMotion(*args))
    __swig_destroy__ = _strongmotion.delete_PeakMotion

    def __eq__(self, other):
        r"""__eq__(PeakMotion self, PeakMotion other) -> bool"""
        return _strongmotion.PeakMotion___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(PeakMotion self, PeakMotion other) -> bool"""
        return _strongmotion.PeakMotion___ne__(self, other)

    def equal(self, other):
        r"""equal(PeakMotion self, PeakMotion other) -> bool"""
        return _strongmotion.PeakMotion_equal(self, other)

    def setMotion(self, motion):
        r"""setMotion(PeakMotion self, RealQuantity motion)"""
        return _strongmotion.PeakMotion_setMotion(self, motion)

    def motion(self, *args):
        r"""
        motion(PeakMotion self) -> RealQuantity
        motion(PeakMotion self) -> RealQuantity
        """
        return _strongmotion.PeakMotion_motion(self, *args)

    def setType(self, type):
        r"""setType(PeakMotion self, std::string const & type)"""
        return _strongmotion.PeakMotion_setType(self, type)

    def type(self):
        r"""type(PeakMotion self) -> std::string const &"""
        return _strongmotion.PeakMotion_type(self)

    def setPeriod(self, period):
        r"""setPeriod(PeakMotion self, Seiscomp::Core::Optional< double > const & period)"""
        return _strongmotion.PeakMotion_setPeriod(self, period)

    def period(self):
        r"""period(PeakMotion self) -> double"""
        return _strongmotion.PeakMotion_period(self)

    def setDamping(self, damping):
        r"""setDamping(PeakMotion self, Seiscomp::Core::Optional< double > const & damping)"""
        return _strongmotion.PeakMotion_setDamping(self, damping)

    def damping(self):
        r"""damping(PeakMotion self) -> double"""
        return _strongmotion.PeakMotion_damping(self)

    def setMethod(self, method):
        r"""setMethod(PeakMotion self, std::string const & method)"""
        return _strongmotion.PeakMotion_setMethod(self, method)

    def method(self):
        r"""method(PeakMotion self) -> std::string const &"""
        return _strongmotion.PeakMotion_method(self)

    def setAtTime(self, atTime):
        r"""setAtTime(PeakMotion self, Seiscomp::Core::Optional< Seiscomp::DataModel::TimeQuantity > const & atTime)"""
        return _strongmotion.PeakMotion_setAtTime(self, atTime)

    def atTime(self, *args):
        r"""
        atTime(PeakMotion self) -> TimeQuantity
        atTime(PeakMotion self) -> TimeQuantity
        """
        return _strongmotion.PeakMotion_atTime(self, *args)

    def record(self):
        r"""record(PeakMotion self) -> Record"""
        return _strongmotion.PeakMotion_record(self)

    def assign(self, other):
        r"""assign(PeakMotion self, Object other) -> bool"""
        return _strongmotion.PeakMotion_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(PeakMotion self, PublicObject parent) -> bool"""
        return _strongmotion.PeakMotion_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(PeakMotion self, PublicObject parent) -> bool"""
        return _strongmotion.PeakMotion_detachFrom(self, parent)

    def detach(self):
        r"""detach(PeakMotion self) -> bool"""
        return _strongmotion.PeakMotion_detach(self)

    def clone(self):
        r"""clone(PeakMotion self) -> Object"""
        return _strongmotion.PeakMotion_clone(self)

    def accept(self, arg2):
        r"""accept(PeakMotion self, Visitor arg2)"""
        return _strongmotion.PeakMotion_accept(self, arg2)

# Register PeakMotion in _strongmotion:
_strongmotion.PeakMotion_swigregister(PeakMotion)
class Record(seiscomp.datamodel.PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::Record 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 _strongmotion.Record_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.Record_TypeInfo()

    def className(self):
        r"""className(Record self) -> char const *"""
        return _strongmotion.Record_className(self)

    def typeInfo(self):
        r"""typeInfo(Record self) -> RTTI"""
        return _strongmotion.Record_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Record
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Record
        """
        return _strongmotion.Record_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Record
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Record
        """
        return _strongmotion.Record_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Record self, GenericArchive ar)"""
        return _strongmotion.Record_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.Record_Meta()

    def meta(self):
        r"""meta(Record self) -> MetaObject"""
        return _strongmotion.Record_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Record self, Record other) -> Record
        __init__(Record self, std::string const & publicID) -> Record
        """
        _strongmotion.Record_swiginit(self, _strongmotion.new_Record(*args))
    __swig_destroy__ = _strongmotion.delete_Record

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Record
        Create(std::string const & publicID) -> Record
        """
        return _strongmotion.Record_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Record"""
        return _strongmotion.Record_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Record self, Record other) -> bool"""
        return _strongmotion.Record___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Record self, Record other) -> bool"""
        return _strongmotion.Record___ne__(self, other)

    def equal(self, other):
        r"""equal(Record self, Record other) -> bool"""
        return _strongmotion.Record_equal(self, other)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(Record self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo > const & creationInfo)"""
        return _strongmotion.Record_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(Record self) -> CreationInfo
        creationInfo(Record self) -> CreationInfo
        """
        return _strongmotion.Record_creationInfo(self, *args)

    def setGainUnit(self, gainUnit):
        r"""setGainUnit(Record self, std::string const & gainUnit)"""
        return _strongmotion.Record_setGainUnit(self, gainUnit)

    def gainUnit(self):
        r"""gainUnit(Record self) -> std::string const &"""
        return _strongmotion.Record_gainUnit(self)

    def setDuration(self, duration):
        r"""setDuration(Record self, Seiscomp::Core::Optional< double > const & duration)"""
        return _strongmotion.Record_setDuration(self, duration)

    def duration(self):
        r"""duration(Record self) -> double"""
        return _strongmotion.Record_duration(self)

    def setStartTime(self, startTime):
        r"""setStartTime(Record self, TimeQuantity startTime)"""
        return _strongmotion.Record_setStartTime(self, startTime)

    def startTime(self, *args):
        r"""
        startTime(Record self) -> TimeQuantity
        startTime(Record self) -> TimeQuantity
        """
        return _strongmotion.Record_startTime(self, *args)

    def setOwner(self, owner):
        r"""setOwner(Record self, Seiscomp::Core::Optional< Seiscomp::DataModel::StrongMotion::Contact > const & owner)"""
        return _strongmotion.Record_setOwner(self, owner)

    def owner(self, *args):
        r"""
        owner(Record self) -> Contact
        owner(Record self) -> Contact
        """
        return _strongmotion.Record_owner(self, *args)

    def setResampleRateNumerator(self, resampleRateNumerator):
        r"""setResampleRateNumerator(Record self, Seiscomp::Core::Optional< int > const & resampleRateNumerator)"""
        return _strongmotion.Record_setResampleRateNumerator(self, resampleRateNumerator)

    def resampleRateNumerator(self):
        r"""resampleRateNumerator(Record self) -> int"""
        return _strongmotion.Record_resampleRateNumerator(self)

    def setResampleRateDenominator(self, resampleRateDenominator):
        r"""setResampleRateDenominator(Record self, Seiscomp::Core::Optional< int > const & resampleRateDenominator)"""
        return _strongmotion.Record_setResampleRateDenominator(self, resampleRateDenominator)

    def resampleRateDenominator(self):
        r"""resampleRateDenominator(Record self) -> int"""
        return _strongmotion.Record_resampleRateDenominator(self)

    def setWaveformID(self, waveformID):
        r"""setWaveformID(Record self, WaveformStreamID waveformID)"""
        return _strongmotion.Record_setWaveformID(self, waveformID)

    def waveformID(self, *args):
        r"""
        waveformID(Record self) -> WaveformStreamID
        waveformID(Record self) -> WaveformStreamID
        """
        return _strongmotion.Record_waveformID(self, *args)

    def setWaveformFile(self, waveformFile):
        r"""setWaveformFile(Record self, Seiscomp::Core::Optional< Seiscomp::DataModel::StrongMotion::FileResource > const & waveformFile)"""
        return _strongmotion.Record_setWaveformFile(self, waveformFile)

    def waveformFile(self, *args):
        r"""
        waveformFile(Record self) -> FileResource
        waveformFile(Record self) -> FileResource
        """
        return _strongmotion.Record_waveformFile(self, *args)

    def add(self, *args):
        r"""
        add(Record self, SimpleFilterChainMember obj) -> bool
        add(Record self, PeakMotion obj) -> bool
        """
        return _strongmotion.Record_add(self, *args)

    def remove(self, *args):
        r"""
        remove(Record self, SimpleFilterChainMember obj) -> bool
        remove(Record self, PeakMotion obj) -> bool
        """
        return _strongmotion.Record_remove(self, *args)

    def removeSimpleFilterChainMember(self, *args):
        r"""
        removeSimpleFilterChainMember(Record self, size_t i) -> bool
        removeSimpleFilterChainMember(Record self, SimpleFilterChainMemberIndex i) -> bool
        """
        return _strongmotion.Record_removeSimpleFilterChainMember(self, *args)

    def removePeakMotion(self, i):
        r"""removePeakMotion(Record self, size_t i) -> bool"""
        return _strongmotion.Record_removePeakMotion(self, i)

    def simpleFilterChainMemberCount(self):
        r"""simpleFilterChainMemberCount(Record self) -> size_t"""
        return _strongmotion.Record_simpleFilterChainMemberCount(self)

    def peakMotionCount(self):
        r"""peakMotionCount(Record self) -> size_t"""
        return _strongmotion.Record_peakMotionCount(self)

    def simpleFilterChainMember(self, *args):
        r"""
        simpleFilterChainMember(Record self, size_t i) -> SimpleFilterChainMember
        simpleFilterChainMember(Record self, SimpleFilterChainMemberIndex i) -> SimpleFilterChainMember
        """
        return _strongmotion.Record_simpleFilterChainMember(self, *args)

    def peakMotion(self, i):
        r"""peakMotion(Record self, size_t i) -> PeakMotion"""
        return _strongmotion.Record_peakMotion(self, i)

    def findPeakMotion(self, peakMotion):
        r"""findPeakMotion(Record self, PeakMotion peakMotion) -> PeakMotion"""
        return _strongmotion.Record_findPeakMotion(self, peakMotion)

    def strongMotionParameters(self):
        r"""strongMotionParameters(Record self) -> StrongMotionParameters"""
        return _strongmotion.Record_strongMotionParameters(self)

    def assign(self, other):
        r"""assign(Record self, Object other) -> bool"""
        return _strongmotion.Record_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Record self, PublicObject parent) -> bool"""
        return _strongmotion.Record_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Record self, PublicObject parent) -> bool"""
        return _strongmotion.Record_detachFrom(self, parent)

    def detach(self):
        r"""detach(Record self) -> bool"""
        return _strongmotion.Record_detach(self)

    def clone(self):
        r"""clone(Record self) -> Object"""
        return _strongmotion.Record_clone(self)

    def updateChild(self, child):
        r"""updateChild(Record self, Object child) -> bool"""
        return _strongmotion.Record_updateChild(self, child)

    def accept(self, arg2):
        r"""accept(Record self, Visitor arg2)"""
        return _strongmotion.Record_accept(self, arg2)

# Register Record in _strongmotion:
_strongmotion.Record_swigregister(Record)
class Rupture(seiscomp.datamodel.PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::Rupture 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 _strongmotion.Rupture_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.Rupture_TypeInfo()

    def className(self):
        r"""className(Rupture self) -> char const *"""
        return _strongmotion.Rupture_className(self)

    def typeInfo(self):
        r"""typeInfo(Rupture self) -> RTTI"""
        return _strongmotion.Rupture_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Rupture
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Rupture
        """
        return _strongmotion.Rupture_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Rupture
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Rupture
        """
        return _strongmotion.Rupture_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(Rupture self, GenericArchive ar)"""
        return _strongmotion.Rupture_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.Rupture_Meta()

    def meta(self):
        r"""meta(Rupture self) -> MetaObject"""
        return _strongmotion.Rupture_meta(self)

    def __init__(self, *args):
        r"""
        __init__(Rupture self, Rupture other) -> Rupture
        __init__(Rupture self, std::string const & publicID) -> Rupture
        """
        _strongmotion.Rupture_swiginit(self, _strongmotion.new_Rupture(*args))
    __swig_destroy__ = _strongmotion.delete_Rupture

    @staticmethod
    def Create(*args):
        r"""
        Create() -> Rupture
        Create(std::string const & publicID) -> Rupture
        """
        return _strongmotion.Rupture_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> Rupture"""
        return _strongmotion.Rupture_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(Rupture self, Rupture other) -> bool"""
        return _strongmotion.Rupture___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(Rupture self, Rupture other) -> bool"""
        return _strongmotion.Rupture___ne__(self, other)

    def equal(self, other):
        r"""equal(Rupture self, Rupture other) -> bool"""
        return _strongmotion.Rupture_equal(self, other)

    def setWidth(self, width):
        r"""setWidth(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & width)"""
        return _strongmotion.Rupture_setWidth(self, width)

    def width(self, *args):
        r"""
        width(Rupture self) -> RealQuantity
        width(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_width(self, *args)

    def setDisplacement(self, displacement):
        r"""setDisplacement(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & displacement)"""
        return _strongmotion.Rupture_setDisplacement(self, displacement)

    def displacement(self, *args):
        r"""
        displacement(Rupture self) -> RealQuantity
        displacement(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_displacement(self, *args)

    def setRiseTime(self, riseTime):
        r"""setRiseTime(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & riseTime)"""
        return _strongmotion.Rupture_setRiseTime(self, riseTime)

    def riseTime(self, *args):
        r"""
        riseTime(Rupture self) -> RealQuantity
        riseTime(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_riseTime(self, *args)

    def setVtToVs(self, vtToVs):
        r"""setVtToVs(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & vtToVs)"""
        return _strongmotion.Rupture_setVtToVs(self, vtToVs)

    def vtToVs(self, *args):
        r"""
        vtToVs(Rupture self) -> RealQuantity
        vtToVs(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_vtToVs(self, *args)

    def setShallowAsperityDepth(self, shallowAsperityDepth):
        r"""setShallowAsperityDepth(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & shallowAsperityDepth)"""
        return _strongmotion.Rupture_setShallowAsperityDepth(self, shallowAsperityDepth)

    def shallowAsperityDepth(self, *args):
        r"""
        shallowAsperityDepth(Rupture self) -> RealQuantity
        shallowAsperityDepth(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_shallowAsperityDepth(self, *args)

    def setShallowAsperity(self, shallowAsperity):
        r"""setShallowAsperity(Rupture self, Seiscomp::Core::Optional< bool > const & shallowAsperity)"""
        return _strongmotion.Rupture_setShallowAsperity(self, shallowAsperity)

    def shallowAsperity(self):
        r"""shallowAsperity(Rupture self) -> bool"""
        return _strongmotion.Rupture_shallowAsperity(self)

    def setLiteratureSource(self, literatureSource):
        r"""setLiteratureSource(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::StrongMotion::LiteratureSource > const & literatureSource)"""
        return _strongmotion.Rupture_setLiteratureSource(self, literatureSource)

    def literatureSource(self, *args):
        r"""
        literatureSource(Rupture self) -> LiteratureSource
        literatureSource(Rupture self) -> LiteratureSource
        """
        return _strongmotion.Rupture_literatureSource(self, *args)

    def setSlipVelocity(self, slipVelocity):
        r"""setSlipVelocity(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & slipVelocity)"""
        return _strongmotion.Rupture_setSlipVelocity(self, slipVelocity)

    def slipVelocity(self, *args):
        r"""
        slipVelocity(Rupture self) -> RealQuantity
        slipVelocity(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_slipVelocity(self, *args)

    def setStrike(self, strike):
        r"""setStrike(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & strike)"""
        return _strongmotion.Rupture_setStrike(self, strike)

    def strike(self, *args):
        r"""
        strike(Rupture self) -> RealQuantity
        strike(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_strike(self, *args)

    def setLength(self, length):
        r"""setLength(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & length)"""
        return _strongmotion.Rupture_setLength(self, length)

    def length(self, *args):
        r"""
        length(Rupture self) -> RealQuantity
        length(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_length(self, *args)

    def setArea(self, area):
        r"""setArea(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & area)"""
        return _strongmotion.Rupture_setArea(self, area)

    def area(self, *args):
        r"""
        area(Rupture self) -> RealQuantity
        area(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_area(self, *args)

    def setRuptureVelocity(self, ruptureVelocity):
        r"""setRuptureVelocity(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & ruptureVelocity)"""
        return _strongmotion.Rupture_setRuptureVelocity(self, ruptureVelocity)

    def ruptureVelocity(self, *args):
        r"""
        ruptureVelocity(Rupture self) -> RealQuantity
        ruptureVelocity(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_ruptureVelocity(self, *args)

    def setStressdrop(self, stressdrop):
        r"""setStressdrop(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & stressdrop)"""
        return _strongmotion.Rupture_setStressdrop(self, stressdrop)

    def stressdrop(self, *args):
        r"""
        stressdrop(Rupture self) -> RealQuantity
        stressdrop(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_stressdrop(self, *args)

    def setMomentReleaseTop5km(self, momentReleaseTop5km):
        r"""setMomentReleaseTop5km(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity > const & momentReleaseTop5km)"""
        return _strongmotion.Rupture_setMomentReleaseTop5km(self, momentReleaseTop5km)

    def momentReleaseTop5km(self, *args):
        r"""
        momentReleaseTop5km(Rupture self) -> RealQuantity
        momentReleaseTop5km(Rupture self) -> RealQuantity
        """
        return _strongmotion.Rupture_momentReleaseTop5km(self, *args)

    def setFwHwIndicator(self, fwHwIndicator):
        r"""setFwHwIndicator(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::StrongMotion::FwHwIndicator > const & fwHwIndicator)"""
        return _strongmotion.Rupture_setFwHwIndicator(self, fwHwIndicator)

    def fwHwIndicator(self):
        r"""fwHwIndicator(Rupture self) -> Seiscomp::DataModel::StrongMotion::FwHwIndicator"""
        return _strongmotion.Rupture_fwHwIndicator(self)

    def setRuptureGeometryWKT(self, ruptureGeometryWKT):
        r"""setRuptureGeometryWKT(Rupture self, std::string const & ruptureGeometryWKT)"""
        return _strongmotion.Rupture_setRuptureGeometryWKT(self, ruptureGeometryWKT)

    def ruptureGeometryWKT(self):
        r"""ruptureGeometryWKT(Rupture self) -> std::string const &"""
        return _strongmotion.Rupture_ruptureGeometryWKT(self)

    def setFaultID(self, faultID):
        r"""setFaultID(Rupture self, std::string const & faultID)"""
        return _strongmotion.Rupture_setFaultID(self, faultID)

    def faultID(self):
        r"""faultID(Rupture self) -> std::string const &"""
        return _strongmotion.Rupture_faultID(self)

    def setSurfaceRupture(self, surfaceRupture):
        r"""setSurfaceRupture(Rupture self, Seiscomp::Core::Optional< Seiscomp::DataModel::StrongMotion::SurfaceRupture > const & surfaceRupture)"""
        return _strongmotion.Rupture_setSurfaceRupture(self, surfaceRupture)

    def surfaceRupture(self, *args):
        r"""
        surfaceRupture(Rupture self) -> SurfaceRupture
        surfaceRupture(Rupture self) -> SurfaceRupture
        """
        return _strongmotion.Rupture_surfaceRupture(self, *args)

    def setCentroidReference(self, centroidReference):
        r"""setCentroidReference(Rupture self, std::string const & centroidReference)"""
        return _strongmotion.Rupture_setCentroidReference(self, centroidReference)

    def centroidReference(self):
        r"""centroidReference(Rupture self) -> std::string const &"""
        return _strongmotion.Rupture_centroidReference(self)

    def strongOriginDescription(self):
        r"""strongOriginDescription(Rupture self) -> StrongOriginDescription"""
        return _strongmotion.Rupture_strongOriginDescription(self)

    def assign(self, other):
        r"""assign(Rupture self, Object other) -> bool"""
        return _strongmotion.Rupture_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(Rupture self, PublicObject parent) -> bool"""
        return _strongmotion.Rupture_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(Rupture self, PublicObject parent) -> bool"""
        return _strongmotion.Rupture_detachFrom(self, parent)

    def detach(self):
        r"""detach(Rupture self) -> bool"""
        return _strongmotion.Rupture_detach(self)

    def clone(self):
        r"""clone(Rupture self) -> Object"""
        return _strongmotion.Rupture_clone(self)

    def updateChild(self, child):
        r"""updateChild(Rupture self, Object child) -> bool"""
        return _strongmotion.Rupture_updateChild(self, child)

    def accept(self, arg2):
        r"""accept(Rupture self, Visitor arg2)"""
        return _strongmotion.Rupture_accept(self, arg2)

# Register Rupture in _strongmotion:
_strongmotion.Rupture_swigregister(Rupture)
class StrongOriginDescription(seiscomp.datamodel.PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::StrongOriginDescription 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 _strongmotion.StrongOriginDescription_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.StrongOriginDescription_TypeInfo()

    def className(self):
        r"""className(StrongOriginDescription self) -> char const *"""
        return _strongmotion.StrongOriginDescription_className(self)

    def typeInfo(self):
        r"""typeInfo(StrongOriginDescription self) -> RTTI"""
        return _strongmotion.StrongOriginDescription_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> StrongOriginDescription
        Cast(Seiscomp::Core::BaseObjectPtr o) -> StrongOriginDescription
        """
        return _strongmotion.StrongOriginDescription_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> StrongOriginDescription
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StrongOriginDescription
        """
        return _strongmotion.StrongOriginDescription_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(StrongOriginDescription self, GenericArchive ar)"""
        return _strongmotion.StrongOriginDescription_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.StrongOriginDescription_Meta()

    def meta(self):
        r"""meta(StrongOriginDescription self) -> MetaObject"""
        return _strongmotion.StrongOriginDescription_meta(self)

    def __init__(self, *args):
        r"""
        __init__(StrongOriginDescription self, StrongOriginDescription other) -> StrongOriginDescription
        __init__(StrongOriginDescription self, std::string const & publicID) -> StrongOriginDescription
        """
        _strongmotion.StrongOriginDescription_swiginit(self, _strongmotion.new_StrongOriginDescription(*args))
    __swig_destroy__ = _strongmotion.delete_StrongOriginDescription

    @staticmethod
    def Create(*args):
        r"""
        Create() -> StrongOriginDescription
        Create(std::string const & publicID) -> StrongOriginDescription
        """
        return _strongmotion.StrongOriginDescription_Create(*args)

    @staticmethod
    def Find(publicID):
        r"""Find(std::string const & publicID) -> StrongOriginDescription"""
        return _strongmotion.StrongOriginDescription_Find(publicID)

    def __eq__(self, other):
        r"""__eq__(StrongOriginDescription self, StrongOriginDescription other) -> bool"""
        return _strongmotion.StrongOriginDescription___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(StrongOriginDescription self, StrongOriginDescription other) -> bool"""
        return _strongmotion.StrongOriginDescription___ne__(self, other)

    def equal(self, other):
        r"""equal(StrongOriginDescription self, StrongOriginDescription other) -> bool"""
        return _strongmotion.StrongOriginDescription_equal(self, other)

    def setOriginID(self, originID):
        r"""setOriginID(StrongOriginDescription self, std::string const & originID)"""
        return _strongmotion.StrongOriginDescription_setOriginID(self, originID)

    def originID(self):
        r"""originID(StrongOriginDescription self) -> std::string const &"""
        return _strongmotion.StrongOriginDescription_originID(self)

    def setWaveformCount(self, waveformCount):
        r"""setWaveformCount(StrongOriginDescription self, Seiscomp::Core::Optional< int > const & waveformCount)"""
        return _strongmotion.StrongOriginDescription_setWaveformCount(self, waveformCount)

    def waveformCount(self):
        r"""waveformCount(StrongOriginDescription self) -> int"""
        return _strongmotion.StrongOriginDescription_waveformCount(self)

    def setCreationInfo(self, creationInfo):
        r"""setCreationInfo(StrongOriginDescription self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo > const & creationInfo)"""
        return _strongmotion.StrongOriginDescription_setCreationInfo(self, creationInfo)

    def creationInfo(self, *args):
        r"""
        creationInfo(StrongOriginDescription self) -> CreationInfo
        creationInfo(StrongOriginDescription self) -> CreationInfo
        """
        return _strongmotion.StrongOriginDescription_creationInfo(self, *args)

    def add(self, *args):
        r"""
        add(StrongOriginDescription self, EventRecordReference obj) -> bool
        add(StrongOriginDescription self, Rupture obj) -> bool
        """
        return _strongmotion.StrongOriginDescription_add(self, *args)

    def remove(self, *args):
        r"""
        remove(StrongOriginDescription self, EventRecordReference obj) -> bool
        remove(StrongOriginDescription self, Rupture obj) -> bool
        """
        return _strongmotion.StrongOriginDescription_remove(self, *args)

    def removeEventRecordReference(self, i):
        r"""removeEventRecordReference(StrongOriginDescription self, size_t i) -> bool"""
        return _strongmotion.StrongOriginDescription_removeEventRecordReference(self, i)

    def removeRupture(self, i):
        r"""removeRupture(StrongOriginDescription self, size_t i) -> bool"""
        return _strongmotion.StrongOriginDescription_removeRupture(self, i)

    def eventRecordReferenceCount(self):
        r"""eventRecordReferenceCount(StrongOriginDescription self) -> size_t"""
        return _strongmotion.StrongOriginDescription_eventRecordReferenceCount(self)

    def ruptureCount(self):
        r"""ruptureCount(StrongOriginDescription self) -> size_t"""
        return _strongmotion.StrongOriginDescription_ruptureCount(self)

    def eventRecordReference(self, i):
        r"""eventRecordReference(StrongOriginDescription self, size_t i) -> EventRecordReference"""
        return _strongmotion.StrongOriginDescription_eventRecordReference(self, i)

    def rupture(self, i):
        r"""rupture(StrongOriginDescription self, size_t i) -> Rupture"""
        return _strongmotion.StrongOriginDescription_rupture(self, i)

    def findEventRecordReference(self, eventRecordReference):
        r"""findEventRecordReference(StrongOriginDescription self, EventRecordReference eventRecordReference) -> EventRecordReference"""
        return _strongmotion.StrongOriginDescription_findEventRecordReference(self, eventRecordReference)

    def findRupture(self, publicID):
        r"""findRupture(StrongOriginDescription self, std::string const & publicID) -> Rupture"""
        return _strongmotion.StrongOriginDescription_findRupture(self, publicID)

    def strongMotionParameters(self):
        r"""strongMotionParameters(StrongOriginDescription self) -> StrongMotionParameters"""
        return _strongmotion.StrongOriginDescription_strongMotionParameters(self)

    def assign(self, other):
        r"""assign(StrongOriginDescription self, Object other) -> bool"""
        return _strongmotion.StrongOriginDescription_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(StrongOriginDescription self, PublicObject parent) -> bool"""
        return _strongmotion.StrongOriginDescription_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(StrongOriginDescription self, PublicObject parent) -> bool"""
        return _strongmotion.StrongOriginDescription_detachFrom(self, parent)

    def detach(self):
        r"""detach(StrongOriginDescription self) -> bool"""
        return _strongmotion.StrongOriginDescription_detach(self)

    def clone(self):
        r"""clone(StrongOriginDescription self) -> Object"""
        return _strongmotion.StrongOriginDescription_clone(self)

    def updateChild(self, child):
        r"""updateChild(StrongOriginDescription self, Object child) -> bool"""
        return _strongmotion.StrongOriginDescription_updateChild(self, child)

    def accept(self, arg2):
        r"""accept(StrongOriginDescription self, Visitor arg2)"""
        return _strongmotion.StrongOriginDescription_accept(self, arg2)

# Register StrongOriginDescription in _strongmotion:
_strongmotion.StrongOriginDescription_swigregister(StrongOriginDescription)
class StrongMotionParameters(seiscomp.datamodel.PublicObject):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::StrongMotionParameters 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 _strongmotion.StrongMotionParameters_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _strongmotion.StrongMotionParameters_TypeInfo()

    def className(self):
        r"""className(StrongMotionParameters self) -> char const *"""
        return _strongmotion.StrongMotionParameters_className(self)

    def typeInfo(self):
        r"""typeInfo(StrongMotionParameters self) -> RTTI"""
        return _strongmotion.StrongMotionParameters_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> StrongMotionParameters
        Cast(Seiscomp::Core::BaseObjectPtr o) -> StrongMotionParameters
        """
        return _strongmotion.StrongMotionParameters_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> StrongMotionParameters
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StrongMotionParameters
        """
        return _strongmotion.StrongMotionParameters_ConstCast(*args)

    def serialize(self, ar):
        r"""serialize(StrongMotionParameters self, GenericArchive ar)"""
        return _strongmotion.StrongMotionParameters_serialize(self, ar)

    @staticmethod
    def Meta():
        r"""Meta() -> MetaObject"""
        return _strongmotion.StrongMotionParameters_Meta()

    def meta(self):
        r"""meta(StrongMotionParameters self) -> MetaObject"""
        return _strongmotion.StrongMotionParameters_meta(self)

    def __init__(self, *args):
        r"""
        __init__(StrongMotionParameters self) -> StrongMotionParameters
        __init__(StrongMotionParameters self, StrongMotionParameters other) -> StrongMotionParameters
        """
        _strongmotion.StrongMotionParameters_swiginit(self, _strongmotion.new_StrongMotionParameters(*args))
    __swig_destroy__ = _strongmotion.delete_StrongMotionParameters

    def __eq__(self, other):
        r"""__eq__(StrongMotionParameters self, StrongMotionParameters other) -> bool"""
        return _strongmotion.StrongMotionParameters___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(StrongMotionParameters self, StrongMotionParameters other) -> bool"""
        return _strongmotion.StrongMotionParameters___ne__(self, other)

    def equal(self, other):
        r"""equal(StrongMotionParameters self, StrongMotionParameters other) -> bool"""
        return _strongmotion.StrongMotionParameters_equal(self, other)

    def add(self, *args):
        r"""
        add(StrongMotionParameters self, SimpleFilter obj) -> bool
        add(StrongMotionParameters self, Record obj) -> bool
        add(StrongMotionParameters self, StrongOriginDescription obj) -> bool
        """
        return _strongmotion.StrongMotionParameters_add(self, *args)

    def remove(self, *args):
        r"""
        remove(StrongMotionParameters self, SimpleFilter obj) -> bool
        remove(StrongMotionParameters self, Record obj) -> bool
        remove(StrongMotionParameters self, StrongOriginDescription obj) -> bool
        """
        return _strongmotion.StrongMotionParameters_remove(self, *args)

    def removeSimpleFilter(self, i):
        r"""removeSimpleFilter(StrongMotionParameters self, size_t i) -> bool"""
        return _strongmotion.StrongMotionParameters_removeSimpleFilter(self, i)

    def removeRecord(self, i):
        r"""removeRecord(StrongMotionParameters self, size_t i) -> bool"""
        return _strongmotion.StrongMotionParameters_removeRecord(self, i)

    def removeStrongOriginDescription(self, i):
        r"""removeStrongOriginDescription(StrongMotionParameters self, size_t i) -> bool"""
        return _strongmotion.StrongMotionParameters_removeStrongOriginDescription(self, i)

    def simpleFilterCount(self):
        r"""simpleFilterCount(StrongMotionParameters self) -> size_t"""
        return _strongmotion.StrongMotionParameters_simpleFilterCount(self)

    def recordCount(self):
        r"""recordCount(StrongMotionParameters self) -> size_t"""
        return _strongmotion.StrongMotionParameters_recordCount(self)

    def strongOriginDescriptionCount(self):
        r"""strongOriginDescriptionCount(StrongMotionParameters self) -> size_t"""
        return _strongmotion.StrongMotionParameters_strongOriginDescriptionCount(self)

    def simpleFilter(self, i):
        r"""simpleFilter(StrongMotionParameters self, size_t i) -> SimpleFilter"""
        return _strongmotion.StrongMotionParameters_simpleFilter(self, i)

    def record(self, i):
        r"""record(StrongMotionParameters self, size_t i) -> Record"""
        return _strongmotion.StrongMotionParameters_record(self, i)

    def strongOriginDescription(self, i):
        r"""strongOriginDescription(StrongMotionParameters self, size_t i) -> StrongOriginDescription"""
        return _strongmotion.StrongMotionParameters_strongOriginDescription(self, i)

    def findSimpleFilter(self, publicID):
        r"""findSimpleFilter(StrongMotionParameters self, std::string const & publicID) -> SimpleFilter"""
        return _strongmotion.StrongMotionParameters_findSimpleFilter(self, publicID)

    def findRecord(self, publicID):
        r"""findRecord(StrongMotionParameters self, std::string const & publicID) -> Record"""
        return _strongmotion.StrongMotionParameters_findRecord(self, publicID)

    def findStrongOriginDescription(self, publicID):
        r"""findStrongOriginDescription(StrongMotionParameters self, std::string const & publicID) -> StrongOriginDescription"""
        return _strongmotion.StrongMotionParameters_findStrongOriginDescription(self, publicID)

    def assign(self, other):
        r"""assign(StrongMotionParameters self, Object other) -> bool"""
        return _strongmotion.StrongMotionParameters_assign(self, other)

    def attachTo(self, parent):
        r"""attachTo(StrongMotionParameters self, PublicObject parent) -> bool"""
        return _strongmotion.StrongMotionParameters_attachTo(self, parent)

    def detachFrom(self, parent):
        r"""detachFrom(StrongMotionParameters self, PublicObject parent) -> bool"""
        return _strongmotion.StrongMotionParameters_detachFrom(self, parent)

    def detach(self):
        r"""detach(StrongMotionParameters self) -> bool"""
        return _strongmotion.StrongMotionParameters_detach(self)

    def clone(self):
        r"""clone(StrongMotionParameters self) -> Object"""
        return _strongmotion.StrongMotionParameters_clone(self)

    def updateChild(self, child):
        r"""updateChild(StrongMotionParameters self, Object child) -> bool"""
        return _strongmotion.StrongMotionParameters_updateChild(self, child)

    def accept(self, arg2):
        r"""accept(StrongMotionParameters self, Visitor arg2)"""
        return _strongmotion.StrongMotionParameters_accept(self, arg2)

# Register StrongMotionParameters in _strongmotion:
_strongmotion.StrongMotionParameters_swigregister(StrongMotionParameters)
class StrongMotionReader(seiscomp.datamodel.DatabaseQuery):
    r"""Proxy of C++ Seiscomp::DataModel::StrongMotion::StrongMotionReader 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__(StrongMotionReader self, DatabaseInterface dbDriver) -> StrongMotionReader"""
        _strongmotion.StrongMotionReader_swiginit(self, _strongmotion.new_StrongMotionReader(dbDriver))
    __swig_destroy__ = _strongmotion.delete_StrongMotionReader

    def loadStrongMotionParameters(self):
        r"""loadStrongMotionParameters(StrongMotionReader self) -> StrongMotionParameters"""
        return _strongmotion.StrongMotionReader_loadStrongMotionParameters(self)

    def loadSimpleFilters(self, arg2):
        r"""loadSimpleFilters(StrongMotionReader self, StrongMotionParameters arg2) -> int"""
        return _strongmotion.StrongMotionReader_loadSimpleFilters(self, arg2)

    def loadRecords(self, arg2):
        r"""loadRecords(StrongMotionReader self, StrongMotionParameters arg2) -> int"""
        return _strongmotion.StrongMotionReader_loadRecords(self, arg2)

    def loadStrongOriginDescriptions(self, arg2):
        r"""loadStrongOriginDescriptions(StrongMotionReader self, StrongMotionParameters arg2) -> int"""
        return _strongmotion.StrongMotionReader_loadStrongOriginDescriptions(self, arg2)

    def loadFilterParameters(self, arg2):
        r"""loadFilterParameters(StrongMotionReader self, SimpleFilter arg2) -> int"""
        return _strongmotion.StrongMotionReader_loadFilterParameters(self, arg2)

    def loadSimpleFilterChainMembers(self, arg2):
        r"""loadSimpleFilterChainMembers(StrongMotionReader self, Record arg2) -> int"""
        return _strongmotion.StrongMotionReader_loadSimpleFilterChainMembers(self, arg2)

    def loadPeakMotions(self, arg2):
        r"""loadPeakMotions(StrongMotionReader self, Record arg2) -> int"""
        return _strongmotion.StrongMotionReader_loadPeakMotions(self, arg2)

    def load(self, *args):
        r"""
        load(StrongMotionReader self, StrongMotionParameters arg2) -> int
        load(StrongMotionReader self, SimpleFilter arg2) -> int
        load(StrongMotionReader self, Record arg2) -> int
        load(StrongMotionReader self, StrongOriginDescription arg2) -> int
        """
        return _strongmotion.StrongMotionReader_load(self, *args)

    def loadEventRecordReferences(self, arg2):
        r"""loadEventRecordReferences(StrongMotionReader self, StrongOriginDescription arg2) -> int"""
        return _strongmotion.StrongMotionReader_loadEventRecordReferences(self, arg2)

    def loadRuptures(self, arg2):
        r"""loadRuptures(StrongMotionReader self, StrongOriginDescription arg2) -> int"""
        return _strongmotion.StrongMotionReader_loadRuptures(self, arg2)

# Register StrongMotionReader in _strongmotion:
_strongmotion.StrongMotionReader_swigregister(StrongMotionReader)