# This file was created by a source code generator:
# genxml2wrap.py 
# Do not modify. Change the definition and
# run the generator again!
#
# (c) 2010 Mathias Hoffmann, GFZ Potsdam
#
#

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)

try: str = unicode
except NameError: pass

import re
import datetime

def Property(func):
        return property(**func())

try:
	import xml.etree.cElementTree as ET  # Python 2.5?
except ImportError:
	import cElementTree as ET

try:
	from decimal import Decimal   # Python 2.4
	_have_decimal = True
except ImportError:
	_have_decimal = False         # Will use float for decimal, hope it works

def _string_fromxml(val):
	if val is None:
		return ""

	return val.strip()

def _string_toxml(val):
	if val is None:
		return ""

	if isinstance(val, bytes):
		try:
			return val.decode("utf-8")
		except UnicodeDecodeError:
			return val.decode("iso-8859-1", "replace")

	return str(val)

def _int_fromxml(val):
	if val is None or val == "":
		return None

	return int(val)

_int_toxml = _string_toxml

def _float_fromxml(val):
	if val is None or val == "":
		return None

	return float(val)

_float_toxml = _string_toxml

if _have_decimal:
	def _decimal_fromxml(val):
		if val is None or val == "":
			return None

		return Decimal(val)
else:
	_decimal_fromxml = _float_fromxml

_decimal_toxml = _string_toxml

def _boolean_fromxml(val):
	if val == "True" or val == "true":
		return True

	return False

def _boolean_toxml(val):
	if val:
		return "true"

	return "false"

# DataModel.DEPLOYMENT == 0
# DataModel.ARRAY == 1
def _StationGroupType_toxml(val):
	if val == 0:
		return "DEPLOYMENT"
	else:
		return "ARRAY"

def _StationGroupType_fromxml(val):
	if val == "DEPLOYMENT":
		return 0
	else:
		return 1

_rx_datetime = re.compile(r"([0-9]{4})-([0-9]{2})-([0-9]{2})T" \
	r"([0-9]{2}):([0-9]{2}):([0-9]{2})(\.([0-9]*))?" \
	r"(Z|([+-])([0-9]{2}):([0-9]{2}))?$")

_rx_date = re.compile(r"([0-9]*)-([0-9]*)-([0-9]*)" \
	r"(Z|([+-])([0-9]{2}):([0-9]{2}))?$")

def _datetime_fromxml(val = ""):
	if val is None or val == "":
		return None
		
	m = _rx_datetime.match(val)
	if m is None:
		m = _rx_date.match(val)
		if m is None:
			raise ValueError("invalid datetime: " + val)

		(year, month, mday, tz, plusminus, tzhours, tzminutes) = m.groups()

		try:
			# ignore time zone
			obj = datetime.datetime(int(year), int(month), int(mday), 0, 0, 0)
		except ValueError:
			raise ValueError("invalid datetime: " + val)
	else:
		(year, month, mday, hour, min, sec, sfdot, sfract,
			tz, plusminus, tzhours, tzminutes) = m.groups()

		if sfract is None:
			sfract = "0"
		
		try:
			obj = datetime.datetime(int(year), int(month), int(mday),
				int(hour), int(min), int(sec), int((sfract + "000000")[:6]))
			if tz is not None and tz != "Z":
				delta = datetime.timedelta(hours = int(tzhours),
					minutes=int(tzminutes))
				if plusminus == "-":
					obj -= delta
				else:
					obj += delta
				
		except ValueError:
			raise ValueError("invalid datetime: " + val)

	return obj

def _datetime_toxml(val):
	if isinstance(val, datetime.datetime):
		return "%04d-%02d-%02dT%02d:%02d:%02d.%04dZ" % 			(val.year, val.month, val.day, val.hour, val.minute,
			val.second, val.microsecond / 100)
	elif isinstance(val, datetime.date):
		return "%04d-%02d-%02d" % (val.year, val.month, val.day)

	elif val is None:
		return ""

	raise ValueError("invalid date or datetime object")

def _get_blob(e, name):
	return _string_fromxml(e.findtext(name)).strip()
	
def _set_blob(e, name, value):
	text = _string_toxml(value).strip()
	e1 = ET.Element(name)
	e1.text = text
	e.append(e1)

def _get_quantity(e, name):
	e1 = e.find(name)
	if e1 is None:
		return quantity()

	return quantity(_float_fromxml(e1.text), unit=_string_fromxml(e1.get("unit")), error=_float_fromxml(e1.get("error")))

def _set_quantity(e, name, value):
	e1 = ET.Element(name)
	e1.text = _float_toxml(value)
	e1.set("unit", _string_toxml(value.unit))
	e1.set("error", _float_toxml(value.error))
	e.append(e1)
#
#




# Inventory::Comment
class xml_Comment(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Comment._xmlns + "comment")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.text = src.text
        self.id = src.id
        self.start = src.start
        self.end = src.end
        # creationInfo is an XML attribute, but we are missing
        # CreationInfo_fromxml() [string->object] and _CreationInfo_toxml()
        # [object->string] serialization within the creationInfo() property.
        # Could be JSON??? Ignore CreationInfo for now.
        #self.creationInfo = src.creationInfo

    def _copy_to(self, dest):
        if self._element.get("text") is not None:
            dest.text = self.text
        if self._element.get("id") is not None:
            dest.id = self.id
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("creationInfo") is not None:
            dest.creationInfo = self.creationInfo

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def text():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("text"))
        def fset(self, value):
            self._element.set("text", _string_toxml(value))
        return locals()

    @Property
    def id():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("id"))
        def fset(self, value):
            self._element.set("id", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def creationInfo():
    # type: CreationInfo
        def fget(self):
            return _CreationInfo_fromxml(self._element.get("creationInfo"))
        def fset(self, value):
            self._element.set("creationInfo", _CreationInfo_toxml(value))
        return locals()


# QualityControl::QCLog
class xml_QCLog(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/QualityControl/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_QCLog._xmlns + "qCLog")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.networkCode = src.networkCode
        self.stationCode = src.stationCode
        self.streamCode = src.streamCode
        self.locationCode = src.locationCode
        self.creatorID = src.creatorID
        self.created = src.created
        self.start = src.start
        self.end = src.end
        self.message = src.message
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("networkCode") is not None:
            dest.networkCode = self.networkCode
        if self._element.get("stationCode") is not None:
            dest.stationCode = self.stationCode
        if self._element.get("streamCode") is not None:
            dest.streamCode = self.streamCode
        if self._element.get("locationCode") is not None:
            dest.locationCode = self.locationCode
        if self._element.get("creatorID") is not None:
            dest.creatorID = self.creatorID
        if self._element.get("created") is not None:
            dest.created = self.created
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("message") is not None:
            dest.message = self.message
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def networkCode():
        def fget(self):
            return _string_fromxml(self._element.get("networkCode"))
        def fset(self, value):
            self._element.set("networkCode", _string_toxml(value))
        return locals()

    @Property
    def stationCode():
        def fget(self):
            return _string_fromxml(self._element.get("stationCode"))
        def fset(self, value):
            self._element.set("stationCode", _string_toxml(value))
        return locals()

    @Property
    def streamCode():
        def fget(self):
            return _string_fromxml(self._element.get("streamCode"))
        def fset(self, value):
            self._element.set("streamCode", _string_toxml(value))
        return locals()

    @Property
    def locationCode():
        def fget(self):
            return _string_fromxml(self._element.get("locationCode"))
        def fset(self, value):
            self._element.set("locationCode", _string_toxml(value))
        return locals()

    @Property
    def creatorID():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("creatorID"))
        def fset(self, value):
            self._element.set("creatorID", _string_toxml(value))
        return locals()

    @Property
    def created():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("created"))
        def fset(self, value):
            self._element.set("created", _datetime_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def message():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("message"))
        def fset(self, value):
            self._element.set("message", _string_toxml(value))
        return locals()


# QualityControl::WaveformQuality
class xml_WaveformQuality(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/QualityControl/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_WaveformQuality._xmlns + "waveformQuality")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.networkCode = src.networkCode
        self.stationCode = src.stationCode
        self.streamCode = src.streamCode
        self.locationCode = src.locationCode
        self.creatorID = src.creatorID
        self.created = src.created
        self.start = src.start
        self.end = src.end
        self.type = src.type
        self.parameter = src.parameter
        self.value = src.value
        self.lowerUncertainty = src.lowerUncertainty
        self.upperUncertainty = src.upperUncertainty
        self.windowLength = src.windowLength

    def _copy_to(self, dest):
        if self._element.get("networkCode") is not None:
            dest.networkCode = self.networkCode
        if self._element.get("stationCode") is not None:
            dest.stationCode = self.stationCode
        if self._element.get("streamCode") is not None:
            dest.streamCode = self.streamCode
        if self._element.get("locationCode") is not None:
            dest.locationCode = self.locationCode
        if self._element.get("creatorID") is not None:
            dest.creatorID = self.creatorID
        if self._element.get("created") is not None:
            dest.created = self.created
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("type") is not None:
            dest.type = self.type
        if self._element.get("parameter") is not None:
            dest.parameter = self.parameter
        if self._element.get("value") is not None:
            dest.value = self.value
        if self._element.get("lowerUncertainty") is not None:
            dest.lowerUncertainty = self.lowerUncertainty
        if self._element.get("upperUncertainty") is not None:
            dest.upperUncertainty = self.upperUncertainty
        if self._element.get("windowLength") is not None:
            dest.windowLength = self.windowLength

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def networkCode():
        def fget(self):
            return _string_fromxml(self._element.get("networkCode"))
        def fset(self, value):
            self._element.set("networkCode", _string_toxml(value))
        return locals()

    @Property
    def stationCode():
        def fget(self):
            return _string_fromxml(self._element.get("stationCode"))
        def fset(self, value):
            self._element.set("stationCode", _string_toxml(value))
        return locals()

    @Property
    def streamCode():
        def fget(self):
            return _string_fromxml(self._element.get("streamCode"))
        def fset(self, value):
            self._element.set("streamCode", _string_toxml(value))
        return locals()

    @Property
    def locationCode():
        def fget(self):
            return _string_fromxml(self._element.get("locationCode"))
        def fset(self, value):
            self._element.set("locationCode", _string_toxml(value))
        return locals()

    @Property
    def creatorID():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("creatorID"))
        def fset(self, value):
            self._element.set("creatorID", _string_toxml(value))
        return locals()

    @Property
    def created():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("created"))
        def fset(self, value):
            self._element.set("created", _datetime_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def type():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("type"))
        def fset(self, value):
            self._element.set("type", _string_toxml(value))
        return locals()

    @Property
    def parameter():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("parameter"))
        def fset(self, value):
            self._element.set("parameter", _string_toxml(value))
        return locals()

    @Property
    def value():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("value"))
        def fset(self, value):
            self._element.set("value", _float_toxml(value))
        return locals()

    @Property
    def lowerUncertainty():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("lowerUncertainty"))
        def fset(self, value):
            self._element.set("lowerUncertainty", _float_toxml(value))
        return locals()

    @Property
    def upperUncertainty():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("upperUncertainty"))
        def fset(self, value):
            self._element.set("upperUncertainty", _float_toxml(value))
        return locals()

    @Property
    def windowLength():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("windowLength"))
        def fset(self, value):
            self._element.set("windowLength", _float_toxml(value))
        return locals()


# QualityControl::Outage
class xml_Outage(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/QualityControl/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Outage._xmlns + "outage")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.networkCode = src.networkCode
        self.stationCode = src.stationCode
        self.streamCode = src.streamCode
        self.locationCode = src.locationCode
        self.creatorID = src.creatorID
        self.created = src.created
        self.start = src.start
        self.end = src.end

    def _copy_to(self, dest):
        if self._element.get("networkCode") is not None:
            dest.networkCode = self.networkCode
        if self._element.get("stationCode") is not None:
            dest.stationCode = self.stationCode
        if self._element.get("streamCode") is not None:
            dest.streamCode = self.streamCode
        if self._element.get("locationCode") is not None:
            dest.locationCode = self.locationCode
        if self._element.get("creatorID") is not None:
            dest.creatorID = self.creatorID
        if self._element.get("created") is not None:
            dest.created = self.created
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def networkCode():
        def fget(self):
            return _string_fromxml(self._element.get("networkCode"))
        def fset(self, value):
            self._element.set("networkCode", _string_toxml(value))
        return locals()

    @Property
    def stationCode():
        def fget(self):
            return _string_fromxml(self._element.get("stationCode"))
        def fset(self, value):
            self._element.set("stationCode", _string_toxml(value))
        return locals()

    @Property
    def streamCode():
        def fget(self):
            return _string_fromxml(self._element.get("streamCode"))
        def fset(self, value):
            self._element.set("streamCode", _string_toxml(value))
        return locals()

    @Property
    def locationCode():
        def fget(self):
            return _string_fromxml(self._element.get("locationCode"))
        def fset(self, value):
            self._element.set("locationCode", _string_toxml(value))
        return locals()

    @Property
    def creatorID():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("creatorID"))
        def fset(self, value):
            self._element.set("creatorID", _string_toxml(value))
        return locals()

    @Property
    def created():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("created"))
        def fset(self, value):
            self._element.set("created", _datetime_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()


# QualityControl::QualityControl
class xml_QualityControl(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/QualityControl/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_QualityControl._xmlns + "qualityControl")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        pass


    def _copy_to(self, dest):
        pass

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    # Aggregation: QCLog
    def _new_log(self):
        return xml_QCLog(ET.Element(xml_QCLog._xmlns + "log"))
    @property
    def log(self):
        for e1 in self._element.findall(xml_QCLog._xmlns + "log"):
            yield xml_QCLog(e1)

    # Aggregation: WaveformQuality
    def _new_waveformQuality(self):
        return xml_WaveformQuality(ET.Element(xml_WaveformQuality._xmlns + "waveformQuality"))
    @property
    def waveformQuality(self):
        for e1 in self._element.findall(xml_WaveformQuality._xmlns + "waveformQuality"):
            yield xml_WaveformQuality(e1)

    # Aggregation: Outage
    def _new_outage(self):
        return xml_Outage(ET.Element(xml_Outage._xmlns + "outage"))
    @property
    def outage(self):
        for e1 in self._element.findall(xml_Outage._xmlns + "outage"):
            yield xml_Outage(e1)


# Inventory::StationReference
class xml_StationReference(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_StationReference._xmlns + "stationReference")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.stationID = src.stationID

    def _copy_to(self, dest):
        if self._element.get("stationID") is not None:
            dest.stationID = self.stationID

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def stationID():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("stationID"))
        def fset(self, value):
            self._element.set("stationID", _string_toxml(value))
        return locals()


# Inventory::StationGroup
class xml_StationGroup(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_StationGroup._xmlns + "stationGroup")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.type = src.type
        self.code = src.code
        self.start = src.start
        self.end = src.end
        self.description = src.description
        self.latitude = src.latitude
        self.longitude = src.longitude
        self.elevation = src.elevation
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("type") is not None:
            dest.type = self.type
        if self._element.get("code") is not None:
            dest.code = self.code
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("description") is not None:
            dest.description = self.description
        if self._element.get("latitude") is not None:
            dest.latitude = self.latitude
        if self._element.get("longitude") is not None:
            dest.longitude = self.longitude
        if self._element.get("elevation") is not None:
            dest.elevation = self.elevation
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def type():
    # type: StationGroupType
        def fget(self):
            return _StationGroupType_fromxml(self._element.get("type"))
        def fset(self, value):
            self._element.set("type", _StationGroupType_toxml(value))
        return locals()

    @Property
    def code():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("code"))
        def fset(self, value):
            self._element.set("code", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def description():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("description"))
        def fset(self, value):
            self._element.set("description", _string_toxml(value))
        return locals()

    @Property
    def latitude():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("latitude"))
        def fset(self, value):
            self._element.set("latitude", _float_toxml(value))
        return locals()

    @Property
    def longitude():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("longitude"))
        def fset(self, value):
            self._element.set("longitude", _float_toxml(value))
        return locals()

    @Property
    def elevation():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("elevation"))
        def fset(self, value):
            self._element.set("elevation", _float_toxml(value))
        return locals()

    # Aggregation: StationReference
    def _new_stationReference(self):
        return xml_StationReference(ET.Element(xml_StationReference._xmlns + "stationReference"))
    @property
    def stationReference(self):
        for e1 in self._element.findall(xml_StationReference._xmlns + "stationReference"):
            yield xml_StationReference(e1)


# Inventory::AuxSource
class xml_AuxSource(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_AuxSource._xmlns + "auxSource")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.description = src.description
        self.unit = src.unit
        self.conversion = src.conversion
        self.sampleRateNumerator = src.sampleRateNumerator
        self.sampleRateDenominator = src.sampleRateDenominator
        self.remark = src.remark

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("description") is not None:
            dest.description = self.description
        if self._element.get("unit") is not None:
            dest.unit = self.unit
        if self._element.get("conversion") is not None:
            dest.conversion = self.conversion
        if self._element.get("sampleRateNumerator") is not None:
            dest.sampleRateNumerator = self.sampleRateNumerator
        if self._element.get("sampleRateDenominator") is not None:
            dest.sampleRateDenominator = self.sampleRateDenominator
        if self._element.find(xml_AuxSource._xmlns + "remark") is not None:
            dest.remark = self.remark

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def description():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("description"))
        def fset(self, value):
            self._element.set("description", _string_toxml(value))
        return locals()

    @Property
    def unit():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("unit"))
        def fset(self, value):
            self._element.set("unit", _string_toxml(value))
        return locals()

    @Property
    def conversion():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("conversion"))
        def fset(self, value):
            self._element.set("conversion", _string_toxml(value))
        return locals()

    @Property
    def sampleRateNumerator():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("sampleRateNumerator"))
        def fset(self, value):
            self._element.set("sampleRateNumerator", _int_toxml(value))
        return locals()

    @Property
    def sampleRateDenominator():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("sampleRateDenominator"))
        def fset(self, value):
            self._element.set("sampleRateDenominator", _int_toxml(value))
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_AuxSource._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_AuxSource._xmlns + "remark", value)
        return locals()


# Inventory::AuxDevice
class xml_AuxDevice(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_AuxDevice._xmlns + "auxDevice")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.description = src.description
        self.model = src.model
        self.manufacturer = src.manufacturer
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("description") is not None:
            dest.description = self.description
        if self._element.get("model") is not None:
            dest.model = self.model
        if self._element.get("manufacturer") is not None:
            dest.manufacturer = self.manufacturer
        if self._element.find(xml_AuxDevice._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def description():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("description"))
        def fset(self, value):
            self._element.set("description", _string_toxml(value))
        return locals()

    @Property
    def model():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("model"))
        def fset(self, value):
            self._element.set("model", _string_toxml(value))
        return locals()

    @Property
    def manufacturer():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("manufacturer"))
        def fset(self, value):
            self._element.set("manufacturer", _string_toxml(value))
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_AuxDevice._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_AuxDevice._xmlns + "remark", value)
        return locals()

    # Aggregation: AuxSource
    def _new_source(self):
        return xml_AuxSource(ET.Element(xml_AuxSource._xmlns + "source"))
    @property
    def source(self):
        for e1 in self._element.findall(xml_AuxSource._xmlns + "source"):
            yield xml_AuxSource(e1)


# Inventory::SensorCalibration
class xml_SensorCalibration(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_SensorCalibration._xmlns + "sensorCalibration")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.serialNumber = src.serialNumber
        self.channel = src.channel
        self.start = src.start
        self.end = src.end
        self.gain = src.gain
        self.gainFrequency = src.gainFrequency
        self.remark = src.remark

    def _copy_to(self, dest):
        if self._element.get("serialNumber") is not None:
            dest.serialNumber = self.serialNumber
        if self._element.get("channel") is not None:
            dest.channel = self.channel
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("gainFrequency") is not None:
            dest.gainFrequency = self.gainFrequency
        if self._element.find(xml_SensorCalibration._xmlns + "remark") is not None:
            dest.remark = self.remark

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def serialNumber():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("serialNumber"))
        def fset(self, value):
            self._element.set("serialNumber", _string_toxml(value))
        return locals()

    @Property
    def channel():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("channel"))
        def fset(self, value):
            self._element.set("channel", _int_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def gainFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gainFrequency"))
        def fset(self, value):
            self._element.set("gainFrequency", _float_toxml(value))
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_SensorCalibration._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_SensorCalibration._xmlns + "remark", value)
        return locals()


# Inventory::Sensor
class xml_Sensor(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Sensor._xmlns + "sensor")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.description = src.description
        self.model = src.model
        self.manufacturer = src.manufacturer
        self.type = src.type
        self.unit = src.unit
        self.lowFrequency = src.lowFrequency
        self.highFrequency = src.highFrequency
        self.response = src.response
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("description") is not None:
            dest.description = self.description
        if self._element.get("model") is not None:
            dest.model = self.model
        if self._element.get("manufacturer") is not None:
            dest.manufacturer = self.manufacturer
        if self._element.get("type") is not None:
            dest.type = self.type
        if self._element.get("unit") is not None:
            dest.unit = self.unit
        if self._element.get("lowFrequency") is not None:
            dest.lowFrequency = self.lowFrequency
        if self._element.get("highFrequency") is not None:
            dest.highFrequency = self.highFrequency
        if self._element.get("response") is not None:
            dest.response = self.response
        if self._element.find(xml_Sensor._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def description():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("description"))
        def fset(self, value):
            self._element.set("description", _string_toxml(value))
        return locals()

    @Property
    def model():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("model"))
        def fset(self, value):
            self._element.set("model", _string_toxml(value))
        return locals()

    @Property
    def manufacturer():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("manufacturer"))
        def fset(self, value):
            self._element.set("manufacturer", _string_toxml(value))
        return locals()

    @Property
    def type():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("type"))
        def fset(self, value):
            self._element.set("type", _string_toxml(value))
        return locals()

    @Property
    def unit():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("unit"))
        def fset(self, value):
            self._element.set("unit", _string_toxml(value))
        return locals()

    @Property
    def lowFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("lowFrequency"))
        def fset(self, value):
            self._element.set("lowFrequency", _float_toxml(value))
        return locals()

    @Property
    def highFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("highFrequency"))
        def fset(self, value):
            self._element.set("highFrequency", _float_toxml(value))
        return locals()

    @Property
    def response():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("response"))
        def fset(self, value):
            self._element.set("response", _string_toxml(value))
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_Sensor._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_Sensor._xmlns + "remark", value)
        return locals()

    # Aggregation: SensorCalibration
    def _new_calibration(self):
        return xml_SensorCalibration(ET.Element(xml_SensorCalibration._xmlns + "calibration"))
    @property
    def calibration(self):
        for e1 in self._element.findall(xml_SensorCalibration._xmlns + "calibration"):
            yield xml_SensorCalibration(e1)


# Inventory::ResponsePAZ
class xml_ResponsePAZ(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_ResponsePAZ._xmlns + "responsePAZ")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.type = src.type
        self.gain = src.gain
        self.gainFrequency = src.gainFrequency
        self.normalizationFactor = src.normalizationFactor
        self.normalizationFrequency = src.normalizationFrequency
        self.numberOfZeros = src.numberOfZeros
        self.numberOfPoles = src.numberOfPoles
        self.zeros = src.zeros
        self.poles = src.poles
        self.remark = src.remark
        self.decimationFactor = src.decimationFactor
        self.delay = src.delay
        self.correction = src.correction
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("type") is not None:
            dest.type = self.type
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("gainFrequency") is not None:
            dest.gainFrequency = self.gainFrequency
        if self._element.get("normalizationFactor") is not None:
            dest.normalizationFactor = self.normalizationFactor
        if self._element.get("normalizationFrequency") is not None:
            dest.normalizationFrequency = self.normalizationFrequency
        if self._element.get("numberOfZeros") is not None:
            dest.numberOfZeros = self.numberOfZeros
        if self._element.get("numberOfPoles") is not None:
            dest.numberOfPoles = self.numberOfPoles
        if self._element.find(xml_ResponsePAZ._xmlns + "zeros") is not None:
            dest.zeros = self.zeros
        if self._element.find(xml_ResponsePAZ._xmlns + "poles") is not None:
            dest.poles = self.poles
        if self._element.find(xml_ResponsePAZ._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("decimationFactor") is not None:
            dest.decimationFactor = self.decimationFactor
        if self._element.get("delay") is not None:
            dest.delay = self.delay
        if self._element.get("correction") is not None:
            dest.correction = self.correction
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def type():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("type"))
        def fset(self, value):
            self._element.set("type", _string_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def gainFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gainFrequency"))
        def fset(self, value):
            self._element.set("gainFrequency", _float_toxml(value))
        return locals()

    @Property
    def normalizationFactor():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("normalizationFactor"))
        def fset(self, value):
            self._element.set("normalizationFactor", _float_toxml(value))
        return locals()

    @Property
    def normalizationFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("normalizationFrequency"))
        def fset(self, value):
            self._element.set("normalizationFrequency", _float_toxml(value))
        return locals()

    @Property
    def numberOfZeros():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("numberOfZeros"))
        def fset(self, value):
            self._element.set("numberOfZeros", _int_toxml(value))
        return locals()

    @Property
    def numberOfPoles():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("numberOfPoles"))
        def fset(self, value):
            self._element.set("numberOfPoles", _int_toxml(value))
        return locals()

    @Property
    def zeros():
    # type: ComplexArray
        def fget(self):
            return _get_blob(self._element, xml_ResponsePAZ._xmlns + "zeros")
        def fset(self, value):
            _set_blob(self._element, xml_ResponsePAZ._xmlns + "zeros", value)
        return locals()

    @Property
    def poles():
    # type: ComplexArray
        def fget(self):
            return _get_blob(self._element, xml_ResponsePAZ._xmlns + "poles")
        def fset(self, value):
            _set_blob(self._element, xml_ResponsePAZ._xmlns + "poles", value)
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_ResponsePAZ._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_ResponsePAZ._xmlns + "remark", value)
        return locals()

    @Property
    def decimationFactor():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("decimationFactor"))
        def fset(self, value):
            self._element.set("decimationFactor", _int_toxml(value))
        return locals()

    @Property
    def delay():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("delay"))
        def fset(self, value):
            self._element.set("delay", _float_toxml(value))
        return locals()

    @Property
    def correction():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("correction"))
        def fset(self, value):
            self._element.set("correction", _float_toxml(value))
        return locals()


# Inventory::ResponsePolynomial
class xml_ResponsePolynomial(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_ResponsePolynomial._xmlns + "responsePolynomial")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.gain = src.gain
        self.gainFrequency = src.gainFrequency
        self.frequencyUnit = src.frequencyUnit
        self.approximationType = src.approximationType
        self.approximationLowerBound = src.approximationLowerBound
        self.approximationUpperBound = src.approximationUpperBound
        self.approximationError = src.approximationError
        self.numberOfCoefficients = src.numberOfCoefficients
        self.coefficients = src.coefficients
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("gainFrequency") is not None:
            dest.gainFrequency = self.gainFrequency
        if self._element.get("frequencyUnit") is not None:
            dest.frequencyUnit = self.frequencyUnit
        if self._element.get("approximationType") is not None:
            dest.approximationType = self.approximationType
        if self._element.get("approximationLowerBound") is not None:
            dest.approximationLowerBound = self.approximationLowerBound
        if self._element.get("approximationUpperBound") is not None:
            dest.approximationUpperBound = self.approximationUpperBound
        if self._element.get("approximationError") is not None:
            dest.approximationError = self.approximationError
        if self._element.get("numberOfCoefficients") is not None:
            dest.numberOfCoefficients = self.numberOfCoefficients
        if self._element.find(xml_ResponsePolynomial._xmlns + "coefficients") is not None:
            dest.coefficients = self.coefficients
        if self._element.find(xml_ResponsePolynomial._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def gainFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gainFrequency"))
        def fset(self, value):
            self._element.set("gainFrequency", _float_toxml(value))
        return locals()

    @Property
    def frequencyUnit():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("frequencyUnit"))
        def fset(self, value):
            self._element.set("frequencyUnit", _string_toxml(value))
        return locals()

    @Property
    def approximationType():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("approximationType"))
        def fset(self, value):
            self._element.set("approximationType", _string_toxml(value))
        return locals()

    @Property
    def approximationLowerBound():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("approximationLowerBound"))
        def fset(self, value):
            self._element.set("approximationLowerBound", _float_toxml(value))
        return locals()

    @Property
    def approximationUpperBound():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("approximationUpperBound"))
        def fset(self, value):
            self._element.set("approximationUpperBound", _float_toxml(value))
        return locals()

    @Property
    def approximationError():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("approximationError"))
        def fset(self, value):
            self._element.set("approximationError", _float_toxml(value))
        return locals()

    @Property
    def numberOfCoefficients():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("numberOfCoefficients"))
        def fset(self, value):
            self._element.set("numberOfCoefficients", _int_toxml(value))
        return locals()

    @Property
    def coefficients():
    # type: RealArray
        def fget(self):
            return _get_blob(self._element, xml_ResponsePolynomial._xmlns + "coefficients")
        def fset(self, value):
            _set_blob(self._element, xml_ResponsePolynomial._xmlns + "coefficients", value)
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_ResponsePolynomial._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_ResponsePolynomial._xmlns + "remark", value)
        return locals()


# Inventory::ResponseFAP
class xml_ResponseFAP(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_ResponseFAP._xmlns + "responseFAP")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.gain = src.gain
        self.gainFrequency = src.gainFrequency
        self.numberOfTuples = src.numberOfTuples
        self.tuples = src.tuples
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("gainFrequency") is not None:
            dest.gainFrequency = self.gainFrequency
        if self._element.get("numberOfTuples") is not None:
            dest.numberOfTuples = self.numberOfTuples
        if self._element.find(xml_ResponseFAP._xmlns + "tuples") is not None:
            dest.tuples = self.tuples
        if self._element.find(xml_ResponseFAP._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def gainFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gainFrequency"))
        def fset(self, value):
            self._element.set("gainFrequency", _float_toxml(value))
        return locals()

    @Property
    def numberOfTuples():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("numberOfTuples"))
        def fset(self, value):
            self._element.set("numberOfTuples", _int_toxml(value))
        return locals()

    @Property
    def tuples():
    # type: RealArray
        def fget(self):
            return _get_blob(self._element, xml_ResponseFAP._xmlns + "tuples")
        def fset(self, value):
            _set_blob(self._element, xml_ResponseFAP._xmlns + "tuples", value)
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_ResponseFAP._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_ResponseFAP._xmlns + "remark", value)
        return locals()


# Inventory::ResponseFIR
class xml_ResponseFIR(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_ResponseFIR._xmlns + "responseFIR")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.gain = src.gain
        self.gainFrequency = src.gainFrequency
        self.decimationFactor = src.decimationFactor
        self.delay = src.delay
        self.correction = src.correction
        self.numberOfCoefficients = src.numberOfCoefficients
        self.symmetry = src.symmetry
        self.coefficients = src.coefficients
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("gainFrequency") is not None:
            dest.gainFrequency = self.gainFrequency
        if self._element.get("decimationFactor") is not None:
            dest.decimationFactor = self.decimationFactor
        if self._element.get("delay") is not None:
            dest.delay = self.delay
        if self._element.get("correction") is not None:
            dest.correction = self.correction
        if self._element.get("numberOfCoefficients") is not None:
            dest.numberOfCoefficients = self.numberOfCoefficients
        if self._element.get("symmetry") is not None:
            dest.symmetry = self.symmetry
        if self._element.find(xml_ResponseFIR._xmlns + "coefficients") is not None:
            dest.coefficients = self.coefficients
        if self._element.find(xml_ResponseFIR._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def gainFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gainFrequency"))
        def fset(self, value):
            self._element.set("gainFrequency", _float_toxml(value))
        return locals()

    @Property
    def decimationFactor():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("decimationFactor"))
        def fset(self, value):
            self._element.set("decimationFactor", _int_toxml(value))
        return locals()

    @Property
    def delay():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("delay"))
        def fset(self, value):
            self._element.set("delay", _float_toxml(value))
        return locals()

    @Property
    def correction():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("correction"))
        def fset(self, value):
            self._element.set("correction", _float_toxml(value))
        return locals()

    @Property
    def numberOfCoefficients():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("numberOfCoefficients"))
        def fset(self, value):
            self._element.set("numberOfCoefficients", _int_toxml(value))
        return locals()

    @Property
    def symmetry():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("symmetry"))
        def fset(self, value):
            self._element.set("symmetry", _string_toxml(value))
        return locals()

    @Property
    def coefficients():
    # type: RealArray
        def fget(self):
            return _get_blob(self._element, xml_ResponseFIR._xmlns + "coefficients")
        def fset(self, value):
            _set_blob(self._element, xml_ResponseFIR._xmlns + "coefficients", value)
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_ResponseFIR._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_ResponseFIR._xmlns + "remark", value)
        return locals()


# Inventory::ResponseIIR
class xml_ResponseIIR(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_ResponseIIR._xmlns + "responseIIR")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.type = src.type
        self.gain = src.gain
        self.gainFrequency = src.gainFrequency
        self.decimationFactor = src.decimationFactor
        self.delay = src.delay
        self.correction = src.correction
        self.numberOfNumerators = src.numberOfNumerators
        self.numberOfDenominators = src.numberOfDenominators
        self.numerators = src.numerators
        self.denominators = src.denominators
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("type") is not None:
            dest.type = self.type
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("gainFrequency") is not None:
            dest.gainFrequency = self.gainFrequency
        if self._element.get("decimationFactor") is not None:
            dest.decimationFactor = self.decimationFactor
        if self._element.get("delay") is not None:
            dest.delay = self.delay
        if self._element.get("correction") is not None:
            dest.correction = self.correction
        if self._element.get("numberOfNumerators") is not None:
            dest.numberOfNumerators = self.numberOfNumerators
        if self._element.get("numberOfDenominators") is not None:
            dest.numberOfDenominators = self.numberOfDenominators
        if self._element.find(xml_ResponseIIR._xmlns + "numerators") is not None:
            dest.numerators = self.numerators
        if self._element.find(xml_ResponseIIR._xmlns + "denominators") is not None:
            dest.denominators = self.denominators
        if self._element.find(xml_ResponseIIR._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def type():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("type"))
        def fset(self, value):
            self._element.set("type", _string_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def gainFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gainFrequency"))
        def fset(self, value):
            self._element.set("gainFrequency", _float_toxml(value))
        return locals()

    @Property
    def decimationFactor():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("decimationFactor"))
        def fset(self, value):
            self._element.set("decimationFactor", _int_toxml(value))
        return locals()

    @Property
    def delay():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("delay"))
        def fset(self, value):
            self._element.set("delay", _float_toxml(value))
        return locals()

    @Property
    def correction():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("correction"))
        def fset(self, value):
            self._element.set("correction", _float_toxml(value))
        return locals()

    @Property
    def numberOfNumerators():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("numberOfNumerators"))
        def fset(self, value):
            self._element.set("numberOfNumerators", _int_toxml(value))
        return locals()

    @Property
    def numberOfDenominators():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("numberOfDenominators"))
        def fset(self, value):
            self._element.set("numberOfDenominators", _int_toxml(value))
        return locals()

    @Property
    def numerators():
    # type: RealArray
        def fget(self):
            return _get_blob(self._element, xml_ResponseIIR._xmlns + "numerators")
        def fset(self, value):
            _set_blob(self._element, xml_ResponseIIR._xmlns + "numerators", value)
        return locals()

    @Property
    def denominators():
    # type: RealArray
        def fget(self):
            return _get_blob(self._element, xml_ResponseIIR._xmlns + "denominators")
        def fset(self, value):
            _set_blob(self._element, xml_ResponseIIR._xmlns + "denominators", value)
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_ResponseIIR._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_ResponseIIR._xmlns + "remark", value)
        return locals()


# Inventory::DataloggerCalibration
class xml_DataloggerCalibration(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_DataloggerCalibration._xmlns + "dataloggerCalibration")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.serialNumber = src.serialNumber
        self.channel = src.channel
        self.start = src.start
        self.end = src.end
        self.gain = src.gain
        self.gainFrequency = src.gainFrequency
        self.remark = src.remark

    def _copy_to(self, dest):
        if self._element.get("serialNumber") is not None:
            dest.serialNumber = self.serialNumber
        if self._element.get("channel") is not None:
            dest.channel = self.channel
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("gainFrequency") is not None:
            dest.gainFrequency = self.gainFrequency
        if self._element.find(xml_DataloggerCalibration._xmlns + "remark") is not None:
            dest.remark = self.remark

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def serialNumber():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("serialNumber"))
        def fset(self, value):
            self._element.set("serialNumber", _string_toxml(value))
        return locals()

    @Property
    def channel():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("channel"))
        def fset(self, value):
            self._element.set("channel", _int_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def gainFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gainFrequency"))
        def fset(self, value):
            self._element.set("gainFrequency", _float_toxml(value))
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_DataloggerCalibration._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_DataloggerCalibration._xmlns + "remark", value)
        return locals()


# Inventory::Decimation
class xml_Decimation(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Decimation._xmlns + "decimation")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.sampleRateNumerator = src.sampleRateNumerator
        self.sampleRateDenominator = src.sampleRateDenominator
        self.analogueFilterChain = src.analogueFilterChain
        self.digitalFilterChain = src.digitalFilterChain

    def _copy_to(self, dest):
        if self._element.get("sampleRateNumerator") is not None:
            dest.sampleRateNumerator = self.sampleRateNumerator
        if self._element.get("sampleRateDenominator") is not None:
            dest.sampleRateDenominator = self.sampleRateDenominator
        if self._element.find(xml_Decimation._xmlns + "analogueFilterChain") is not None:
            dest.analogueFilterChain = self.analogueFilterChain
        if self._element.find(xml_Decimation._xmlns + "digitalFilterChain") is not None:
            dest.digitalFilterChain = self.digitalFilterChain

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def sampleRateNumerator():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("sampleRateNumerator"))
        def fset(self, value):
            self._element.set("sampleRateNumerator", _int_toxml(value))
        return locals()

    @Property
    def sampleRateDenominator():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("sampleRateDenominator"))
        def fset(self, value):
            self._element.set("sampleRateDenominator", _int_toxml(value))
        return locals()

    @Property
    def analogueFilterChain():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_Decimation._xmlns + "analogueFilterChain")
        def fset(self, value):
            _set_blob(self._element, xml_Decimation._xmlns + "analogueFilterChain", value)
        return locals()

    @Property
    def digitalFilterChain():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_Decimation._xmlns + "digitalFilterChain")
        def fset(self, value):
            _set_blob(self._element, xml_Decimation._xmlns + "digitalFilterChain", value)
        return locals()


# Inventory::Datalogger
class xml_Datalogger(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Datalogger._xmlns + "datalogger")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.name = src.name
        self.description = src.description
        self.digitizerModel = src.digitizerModel
        self.digitizerManufacturer = src.digitizerManufacturer
        self.recorderModel = src.recorderModel
        self.recorderManufacturer = src.recorderManufacturer
        self.clockModel = src.clockModel
        self.clockManufacturer = src.clockManufacturer
        self.clockType = src.clockType
        self.gain = src.gain
        self.maxClockDrift = src.maxClockDrift
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("name") is not None:
            dest.name = self.name
        if self._element.get("description") is not None:
            dest.description = self.description
        if self._element.get("digitizerModel") is not None:
            dest.digitizerModel = self.digitizerModel
        if self._element.get("digitizerManufacturer") is not None:
            dest.digitizerManufacturer = self.digitizerManufacturer
        if self._element.get("recorderModel") is not None:
            dest.recorderModel = self.recorderModel
        if self._element.get("recorderManufacturer") is not None:
            dest.recorderManufacturer = self.recorderManufacturer
        if self._element.get("clockModel") is not None:
            dest.clockModel = self.clockModel
        if self._element.get("clockManufacturer") is not None:
            dest.clockManufacturer = self.clockManufacturer
        if self._element.get("clockType") is not None:
            dest.clockType = self.clockType
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("maxClockDrift") is not None:
            dest.maxClockDrift = self.maxClockDrift
        if self._element.find(xml_Datalogger._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def name():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("name"))
        def fset(self, value):
            self._element.set("name", _string_toxml(value))
        return locals()

    @Property
    def description():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("description"))
        def fset(self, value):
            self._element.set("description", _string_toxml(value))
        return locals()

    @Property
    def digitizerModel():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("digitizerModel"))
        def fset(self, value):
            self._element.set("digitizerModel", _string_toxml(value))
        return locals()

    @Property
    def digitizerManufacturer():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("digitizerManufacturer"))
        def fset(self, value):
            self._element.set("digitizerManufacturer", _string_toxml(value))
        return locals()

    @Property
    def recorderModel():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("recorderModel"))
        def fset(self, value):
            self._element.set("recorderModel", _string_toxml(value))
        return locals()

    @Property
    def recorderManufacturer():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("recorderManufacturer"))
        def fset(self, value):
            self._element.set("recorderManufacturer", _string_toxml(value))
        return locals()

    @Property
    def clockModel():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("clockModel"))
        def fset(self, value):
            self._element.set("clockModel", _string_toxml(value))
        return locals()

    @Property
    def clockManufacturer():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("clockManufacturer"))
        def fset(self, value):
            self._element.set("clockManufacturer", _string_toxml(value))
        return locals()

    @Property
    def clockType():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("clockType"))
        def fset(self, value):
            self._element.set("clockType", _string_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def maxClockDrift():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("maxClockDrift"))
        def fset(self, value):
            self._element.set("maxClockDrift", _float_toxml(value))
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_Datalogger._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_Datalogger._xmlns + "remark", value)
        return locals()

    # Aggregation: DataloggerCalibration
    def _new_calibration(self):
        return xml_DataloggerCalibration(ET.Element(xml_DataloggerCalibration._xmlns + "calibration"))
    @property
    def calibration(self):
        for e1 in self._element.findall(xml_DataloggerCalibration._xmlns + "calibration"):
            yield xml_DataloggerCalibration(e1)

    # Aggregation: Decimation
    def _new_decimation(self):
        return xml_Decimation(ET.Element(xml_Decimation._xmlns + "decimation"))
    @property
    def decimation(self):
        for e1 in self._element.findall(xml_Decimation._xmlns + "decimation"):
            yield xml_Decimation(e1)


# Inventory::AuxStream
class xml_AuxStream(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_AuxStream._xmlns + "auxStream")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.code = src.code
        self.start = src.start
        self.end = src.end
        self.device = src.device
        self.deviceSerialNumber = src.deviceSerialNumber
        self.source = src.source
        self.format = src.format
        self.flags = src.flags
        self.restricted = src.restricted
        self.shared = src.shared

    def _copy_to(self, dest):
        if self._element.get("code") is not None:
            dest.code = self.code
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("device") is not None:
            dest.device = self.device
        if self._element.get("deviceSerialNumber") is not None:
            dest.deviceSerialNumber = self.deviceSerialNumber
        if self._element.get("source") is not None:
            dest.source = self.source
        if self._element.get("format") is not None:
            dest.format = self.format
        if self._element.get("flags") is not None:
            dest.flags = self.flags
        if self._element.get("restricted") is not None:
            dest.restricted = self.restricted
        if self._element.get("shared") is not None:
            dest.shared = self.shared

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def code():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("code"))
        def fset(self, value):
            self._element.set("code", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def device():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("device"))
        def fset(self, value):
            self._element.set("device", _string_toxml(value))
        return locals()

    @Property
    def deviceSerialNumber():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("deviceSerialNumber"))
        def fset(self, value):
            self._element.set("deviceSerialNumber", _string_toxml(value))
        return locals()

    @Property
    def source():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("source"))
        def fset(self, value):
            self._element.set("source", _string_toxml(value))
        return locals()

    @Property
    def format():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("format"))
        def fset(self, value):
            self._element.set("format", _string_toxml(value))
        return locals()

    @Property
    def flags():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("flags"))
        def fset(self, value):
            self._element.set("flags", _string_toxml(value))
        return locals()

    @Property
    def restricted():
    # type: boolean
        def fget(self):
            return _boolean_fromxml(self._element.get("restricted"))
        def fset(self, value):
            self._element.set("restricted", _boolean_toxml(value))
        return locals()

    @Property
    def shared():
    # type: boolean
        def fget(self):
            return _boolean_fromxml(self._element.get("shared"))
        def fset(self, value):
            self._element.set("shared", _boolean_toxml(value))
        return locals()


# Inventory::Stream
class xml_Stream(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Stream._xmlns + "stream")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.code = src.code
        self.start = src.start
        self.end = src.end
        self.datalogger = src.datalogger
        self.dataloggerSerialNumber = src.dataloggerSerialNumber
        self.dataloggerChannel = src.dataloggerChannel
        self.sensor = src.sensor
        self.sensorSerialNumber = src.sensorSerialNumber
        self.sensorChannel = src.sensorChannel
        self.clockSerialNumber = src.clockSerialNumber
        self.sampleRateNumerator = src.sampleRateNumerator
        self.sampleRateDenominator = src.sampleRateDenominator
        self.depth = src.depth
        self.azimuth = src.azimuth
        self.dip = src.dip
        self.gain = src.gain
        self.gainFrequency = src.gainFrequency
        self.gainUnit = src.gainUnit
        self.format = src.format
        self.flags = src.flags
        self.restricted = src.restricted
        self.shared = src.shared
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("code") is not None:
            dest.code = self.code
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("datalogger") is not None:
            dest.datalogger = self.datalogger
        if self._element.get("dataloggerSerialNumber") is not None:
            dest.dataloggerSerialNumber = self.dataloggerSerialNumber
        if self._element.get("dataloggerChannel") is not None:
            dest.dataloggerChannel = self.dataloggerChannel
        if self._element.get("sensor") is not None:
            dest.sensor = self.sensor
        if self._element.get("sensorSerialNumber") is not None:
            dest.sensorSerialNumber = self.sensorSerialNumber
        if self._element.get("sensorChannel") is not None:
            dest.sensorChannel = self.sensorChannel
        if self._element.get("clockSerialNumber") is not None:
            dest.clockSerialNumber = self.clockSerialNumber
        if self._element.get("sampleRateNumerator") is not None:
            dest.sampleRateNumerator = self.sampleRateNumerator
        if self._element.get("sampleRateDenominator") is not None:
            dest.sampleRateDenominator = self.sampleRateDenominator
        if self._element.get("depth") is not None:
            dest.depth = self.depth
        if self._element.get("azimuth") is not None:
            dest.azimuth = self.azimuth
        if self._element.get("dip") is not None:
            dest.dip = self.dip
        if self._element.get("gain") is not None:
            dest.gain = self.gain
        if self._element.get("gainFrequency") is not None:
            dest.gainFrequency = self.gainFrequency
        if self._element.get("gainUnit") is not None:
            dest.gainUnit = self.gainUnit
        if self._element.get("format") is not None:
            dest.format = self.format
        if self._element.get("flags") is not None:
            dest.flags = self.flags
        if self._element.get("restricted") is not None:
            dest.restricted = self.restricted
        if self._element.get("shared") is not None:
            dest.shared = self.shared
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def code():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("code"))
        def fset(self, value):
            self._element.set("code", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def datalogger():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("datalogger"))
        def fset(self, value):
            self._element.set("datalogger", _string_toxml(value))
        return locals()

    @Property
    def dataloggerSerialNumber():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("dataloggerSerialNumber"))
        def fset(self, value):
            self._element.set("dataloggerSerialNumber", _string_toxml(value))
        return locals()

    @Property
    def dataloggerChannel():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("dataloggerChannel"))
        def fset(self, value):
            self._element.set("dataloggerChannel", _int_toxml(value))
        return locals()

    @Property
    def sensor():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("sensor"))
        def fset(self, value):
            self._element.set("sensor", _string_toxml(value))
        return locals()

    @Property
    def sensorSerialNumber():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("sensorSerialNumber"))
        def fset(self, value):
            self._element.set("sensorSerialNumber", _string_toxml(value))
        return locals()

    @Property
    def sensorChannel():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("sensorChannel"))
        def fset(self, value):
            self._element.set("sensorChannel", _int_toxml(value))
        return locals()

    @Property
    def clockSerialNumber():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("clockSerialNumber"))
        def fset(self, value):
            self._element.set("clockSerialNumber", _string_toxml(value))
        return locals()

    @Property
    def sampleRateNumerator():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("sampleRateNumerator"))
        def fset(self, value):
            self._element.set("sampleRateNumerator", _int_toxml(value))
        return locals()

    @Property
    def sampleRateDenominator():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("sampleRateDenominator"))
        def fset(self, value):
            self._element.set("sampleRateDenominator", _int_toxml(value))
        return locals()

    @Property
    def depth():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("depth"))
        def fset(self, value):
            self._element.set("depth", _float_toxml(value))
        return locals()

    @Property
    def azimuth():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("azimuth"))
        def fset(self, value):
            self._element.set("azimuth", _float_toxml(value))
        return locals()

    @Property
    def dip():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("dip"))
        def fset(self, value):
            self._element.set("dip", _float_toxml(value))
        return locals()

    @Property
    def gain():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gain"))
        def fset(self, value):
            self._element.set("gain", _float_toxml(value))
        return locals()

    @Property
    def gainFrequency():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("gainFrequency"))
        def fset(self, value):
            self._element.set("gainFrequency", _float_toxml(value))
        return locals()

    @Property
    def gainUnit():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("gainUnit"))
        def fset(self, value):
            self._element.set("gainUnit", _string_toxml(value))
        return locals()

    @Property
    def format():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("format"))
        def fset(self, value):
            self._element.set("format", _string_toxml(value))
        return locals()

    @Property
    def flags():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("flags"))
        def fset(self, value):
            self._element.set("flags", _string_toxml(value))
        return locals()

    @Property
    def restricted():
    # type: boolean
        def fget(self):
            return _boolean_fromxml(self._element.get("restricted"))
        def fset(self, value):
            self._element.set("restricted", _boolean_toxml(value))
        return locals()

    @Property
    def shared():
    # type: boolean
        def fget(self):
            return _boolean_fromxml(self._element.get("shared"))
        def fset(self, value):
            self._element.set("shared", _boolean_toxml(value))
        return locals()

    # Aggregation: Comment
    def _new_comment(self):
        return xml_Comment(ET.Element(xml_Comment._xmlns + "comment"))
    @property
    def comment(self):
        for e1 in self._element.findall(xml_Comment._xmlns + "comment"):
            yield xml_Comment(e1)


# Inventory::SensorLocation
class xml_SensorLocation(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_SensorLocation._xmlns + "sensorLocation")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.code = src.code
        self.start = src.start
        self.end = src.end
        self.latitude = src.latitude
        self.longitude = src.longitude
        self.elevation = src.elevation
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("code") is not None:
            dest.code = self.code
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("latitude") is not None:
            dest.latitude = self.latitude
        if self._element.get("longitude") is not None:
            dest.longitude = self.longitude
        if self._element.get("elevation") is not None:
            dest.elevation = self.elevation
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def code():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("code"))
        def fset(self, value):
            self._element.set("code", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def latitude():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("latitude"))
        def fset(self, value):
            self._element.set("latitude", _float_toxml(value))
        return locals()

    @Property
    def longitude():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("longitude"))
        def fset(self, value):
            self._element.set("longitude", _float_toxml(value))
        return locals()

    @Property
    def elevation():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("elevation"))
        def fset(self, value):
            self._element.set("elevation", _float_toxml(value))
        return locals()

    # Aggregation: Comment
    def _new_comment(self):
        return xml_Comment(ET.Element(xml_Comment._xmlns + "comment"))
    @property
    def comment(self):
        for e1 in self._element.findall(xml_Comment._xmlns + "comment"):
            yield xml_Comment(e1)

    # Aggregation: AuxStream
    def _new_auxStream(self):
        return xml_AuxStream(ET.Element(xml_AuxStream._xmlns + "auxStream"))
    @property
    def auxStream(self):
        for e1 in self._element.findall(xml_AuxStream._xmlns + "auxStream"):
            yield xml_AuxStream(e1)

    # Aggregation: Stream
    def _new_stream(self):
        return xml_Stream(ET.Element(xml_Stream._xmlns + "stream"))
    @property
    def stream(self):
        for e1 in self._element.findall(xml_Stream._xmlns + "stream"):
            yield xml_Stream(e1)


# Inventory::Station
class xml_Station(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Station._xmlns + "station")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.code = src.code
        self.start = src.start
        self.end = src.end
        self.description = src.description
        self.latitude = src.latitude
        self.longitude = src.longitude
        self.elevation = src.elevation
        self.place = src.place
        self.country = src.country
        self.affiliation = src.affiliation
        self.type = src.type
        self.archive = src.archive
        self.archiveNetworkCode = src.archiveNetworkCode
        self.restricted = src.restricted
        self.shared = src.shared
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("code") is not None:
            dest.code = self.code
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("description") is not None:
            dest.description = self.description
        if self._element.get("latitude") is not None:
            dest.latitude = self.latitude
        if self._element.get("longitude") is not None:
            dest.longitude = self.longitude
        if self._element.get("elevation") is not None:
            dest.elevation = self.elevation
        if self._element.get("place") is not None:
            dest.place = self.place
        if self._element.get("country") is not None:
            dest.country = self.country
        if self._element.get("affiliation") is not None:
            dest.affiliation = self.affiliation
        if self._element.get("type") is not None:
            dest.type = self.type
        if self._element.get("archive") is not None:
            dest.archive = self.archive
        if self._element.get("archiveNetworkCode") is not None:
            dest.archiveNetworkCode = self.archiveNetworkCode
        if self._element.get("restricted") is not None:
            dest.restricted = self.restricted
        if self._element.get("shared") is not None:
            dest.shared = self.shared
        if self._element.find(xml_Station._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def code():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("code"))
        def fset(self, value):
            self._element.set("code", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def description():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("description"))
        def fset(self, value):
            self._element.set("description", _string_toxml(value))
        return locals()

    @Property
    def latitude():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("latitude"))
        def fset(self, value):
            self._element.set("latitude", _float_toxml(value))
        return locals()

    @Property
    def longitude():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("longitude"))
        def fset(self, value):
            self._element.set("longitude", _float_toxml(value))
        return locals()

    @Property
    def elevation():
    # type: float
        def fget(self):
            return _float_fromxml(self._element.get("elevation"))
        def fset(self, value):
            self._element.set("elevation", _float_toxml(value))
        return locals()

    @Property
    def place():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("place"))
        def fset(self, value):
            self._element.set("place", _string_toxml(value))
        return locals()

    @Property
    def country():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("country"))
        def fset(self, value):
            self._element.set("country", _string_toxml(value))
        return locals()

    @Property
    def affiliation():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("affiliation"))
        def fset(self, value):
            self._element.set("affiliation", _string_toxml(value))
        return locals()

    @Property
    def type():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("type"))
        def fset(self, value):
            self._element.set("type", _string_toxml(value))
        return locals()

    @Property
    def archive():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("archive"))
        def fset(self, value):
            self._element.set("archive", _string_toxml(value))
        return locals()

    @Property
    def archiveNetworkCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("archiveNetworkCode"))
        def fset(self, value):
            self._element.set("archiveNetworkCode", _string_toxml(value))
        return locals()

    @Property
    def restricted():
    # type: boolean
        def fget(self):
            return _boolean_fromxml(self._element.get("restricted"))
        def fset(self, value):
            self._element.set("restricted", _boolean_toxml(value))
        return locals()

    @Property
    def shared():
    # type: boolean
        def fget(self):
            return _boolean_fromxml(self._element.get("shared"))
        def fset(self, value):
            self._element.set("shared", _boolean_toxml(value))
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_Station._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_Station._xmlns + "remark", value)
        return locals()

    # Aggregation: Comment
    def _new_comment(self):
        return xml_Comment(ET.Element(xml_Comment._xmlns + "comment"))
    @property
    def comment(self):
        for e1 in self._element.findall(xml_Comment._xmlns + "comment"):
            yield xml_Comment(e1)

    # Aggregation: SensorLocation
    def _new_sensorLocation(self):
        return xml_SensorLocation(ET.Element(xml_SensorLocation._xmlns + "sensorLocation"))
    @property
    def sensorLocation(self):
        for e1 in self._element.findall(xml_SensorLocation._xmlns + "sensorLocation"):
            yield xml_SensorLocation(e1)


# Inventory::Network
class xml_Network(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Network._xmlns + "network")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.code = src.code
        self.start = src.start
        self.end = src.end
        self.description = src.description
        self.institutions = src.institutions
        self.region = src.region
        self.type = src.type
        self.netClass = src.netClass
        self.archive = src.archive
        self.restricted = src.restricted
        self.shared = src.shared
        self.remark = src.remark
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("code") is not None:
            dest.code = self.code
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("description") is not None:
            dest.description = self.description
        if self._element.get("institutions") is not None:
            dest.institutions = self.institutions
        if self._element.get("region") is not None:
            dest.region = self.region
        if self._element.get("type") is not None:
            dest.type = self.type
        if self._element.get("netClass") is not None:
            dest.netClass = self.netClass
        if self._element.get("archive") is not None:
            dest.archive = self.archive
        if self._element.get("restricted") is not None:
            dest.restricted = self.restricted
        if self._element.get("shared") is not None:
            dest.shared = self.shared
        if self._element.find(xml_Network._xmlns + "remark") is not None:
            dest.remark = self.remark
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def code():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("code"))
        def fset(self, value):
            self._element.set("code", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def description():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("description"))
        def fset(self, value):
            self._element.set("description", _string_toxml(value))
        return locals()

    @Property
    def institutions():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("institutions"))
        def fset(self, value):
            self._element.set("institutions", _string_toxml(value))
        return locals()

    @Property
    def region():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("region"))
        def fset(self, value):
            self._element.set("region", _string_toxml(value))
        return locals()

    @Property
    def type():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("type"))
        def fset(self, value):
            self._element.set("type", _string_toxml(value))
        return locals()

    @Property
    def netClass():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("netClass"))
        def fset(self, value):
            self._element.set("netClass", _string_toxml(value))
        return locals()

    @Property
    def archive():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("archive"))
        def fset(self, value):
            self._element.set("archive", _string_toxml(value))
        return locals()

    @Property
    def restricted():
    # type: boolean
        def fget(self):
            return _boolean_fromxml(self._element.get("restricted"))
        def fset(self, value):
            self._element.set("restricted", _boolean_toxml(value))
        return locals()

    @Property
    def shared():
    # type: boolean
        def fget(self):
            return _boolean_fromxml(self._element.get("shared"))
        def fset(self, value):
            self._element.set("shared", _boolean_toxml(value))
        return locals()

    @Property
    def remark():
    # type: Blob
        def fget(self):
            return _get_blob(self._element, xml_Network._xmlns + "remark")
        def fset(self, value):
            _set_blob(self._element, xml_Network._xmlns + "remark", value)
        return locals()

    # Aggregation: Comment
    def _new_comment(self):
        return xml_Comment(ET.Element(xml_Comment._xmlns + "comment"))
    @property
    def comment(self):
        for e1 in self._element.findall(xml_Comment._xmlns + "comment"):
            yield xml_Comment(e1)

    # Aggregation: Station
    def _new_station(self):
        return xml_Station(ET.Element(xml_Station._xmlns + "station"))
    @property
    def station(self):
        for e1 in self._element.findall(xml_Station._xmlns + "station"):
            yield xml_Station(e1)


# Inventory::Inventory
class xml_Inventory(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Inventory._xmlns + "inventory")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        pass


    def _copy_to(self, dest):
        pass

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    # Aggregation: StationGroup
    def _new_stationGroup(self):
        return xml_StationGroup(ET.Element(xml_StationGroup._xmlns + "stationGroup"))
    @property
    def stationGroup(self):
        for e1 in self._element.findall(xml_StationGroup._xmlns + "stationGroup"):
            yield xml_StationGroup(e1)

    # Aggregation: AuxDevice
    def _new_auxDevice(self):
        return xml_AuxDevice(ET.Element(xml_AuxDevice._xmlns + "auxDevice"))
    @property
    def auxDevice(self):
        for e1 in self._element.findall(xml_AuxDevice._xmlns + "auxDevice"):
            yield xml_AuxDevice(e1)

    # Aggregation: Sensor
    def _new_sensor(self):
        return xml_Sensor(ET.Element(xml_Sensor._xmlns + "sensor"))
    @property
    def sensor(self):
        for e1 in self._element.findall(xml_Sensor._xmlns + "sensor"):
            yield xml_Sensor(e1)

    # Aggregation: Datalogger
    def _new_datalogger(self):
        return xml_Datalogger(ET.Element(xml_Datalogger._xmlns + "datalogger"))
    @property
    def datalogger(self):
        for e1 in self._element.findall(xml_Datalogger._xmlns + "datalogger"):
            yield xml_Datalogger(e1)

    # Aggregation: ResponsePAZ
    def _new_responsePAZ(self):
        return xml_ResponsePAZ(ET.Element(xml_ResponsePAZ._xmlns + "responsePAZ"))
    @property
    def responsePAZ(self):
        for e1 in self._element.findall(xml_ResponsePAZ._xmlns + "responsePAZ"):
            yield xml_ResponsePAZ(e1)

    # Aggregation: ResponseFIR
    def _new_responseFIR(self):
        return xml_ResponseFIR(ET.Element(xml_ResponseFIR._xmlns + "responseFIR"))
    @property
    def responseFIR(self):
        for e1 in self._element.findall(xml_ResponseFIR._xmlns + "responseFIR"):
            yield xml_ResponseFIR(e1)

    # Aggregation: ResponseIIR
    def _new_responseIIR(self):
        return xml_ResponseIIR(ET.Element(xml_ResponseIIR._xmlns + "responseIIR"))
    @property
    def responseIIR(self):
        for e1 in self._element.findall(xml_ResponseIIR._xmlns + "responseIIR"):
            yield xml_ResponseIIR(e1)

    # Aggregation: ResponsePolynomial
    def _new_responsePolynomial(self):
        return xml_ResponsePolynomial(ET.Element(xml_ResponsePolynomial._xmlns + "responsePolynomial"))
    @property
    def responsePolynomial(self):
        for e1 in self._element.findall(xml_ResponsePolynomial._xmlns + "responsePolynomial"):
            yield xml_ResponsePolynomial(e1)

    # Aggregation: ResponseFAP
    def _new_responseFAP(self):
        return xml_ResponseFAP(ET.Element(xml_ResponseFAP._xmlns + "responseFAP"))
    @property
    def responseFAP(self):
        for e1 in self._element.findall(xml_ResponseFAP._xmlns + "responseFAP"):
            yield xml_ResponseFAP(e1)

    # Aggregation: Network
    def _new_network(self):
        return xml_Network(ET.Element(xml_Network._xmlns + "network"))
    @property
    def network(self):
        for e1 in self._element.findall(xml_Network._xmlns + "network"):
            yield xml_Network(e1)


# Routing::RouteArclink
class xml_RouteArclink(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_RouteArclink._xmlns + "routeArclink")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.address = src.address
        self.start = src.start
        self.end = src.end
        self.priority = src.priority

    def _copy_to(self, dest):
        if self._element.get("address") is not None:
            dest.address = self.address
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end
        if self._element.get("priority") is not None:
            dest.priority = self.priority

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def address():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("address"))
        def fset(self, value):
            self._element.set("address", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()

    @Property
    def priority():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("priority"))
        def fset(self, value):
            self._element.set("priority", _int_toxml(value))
        return locals()


# Routing::RouteSeedlink
class xml_RouteSeedlink(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_RouteSeedlink._xmlns + "routeSeedlink")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.address = src.address
        self.priority = src.priority

    def _copy_to(self, dest):
        if self._element.get("address") is not None:
            dest.address = self.address
        if self._element.get("priority") is not None:
            dest.priority = self.priority

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def address():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("address"))
        def fset(self, value):
            self._element.set("address", _string_toxml(value))
        return locals()

    @Property
    def priority():
    # type: int
        def fget(self):
            return _int_fromxml(self._element.get("priority"))
        def fset(self, value):
            self._element.set("priority", _int_toxml(value))
        return locals()


# Routing::Route
class xml_Route(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Route._xmlns + "route")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.networkCode = src.networkCode
        self.stationCode = src.stationCode
        self.locationCode = src.locationCode
        self.streamCode = src.streamCode
        self.publicID = src.publicID

    def _copy_to(self, dest):
        if self._element.get("networkCode") is not None:
            dest.networkCode = self.networkCode
        if self._element.get("stationCode") is not None:
            dest.stationCode = self.stationCode
        if self._element.get("locationCode") is not None:
            dest.locationCode = self.locationCode
        if self._element.get("streamCode") is not None:
            dest.streamCode = self.streamCode
        if self._element.get("publicID") is not None:
            dest.publicID = self.publicID

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def networkCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("networkCode"))
        def fset(self, value):
            self._element.set("networkCode", _string_toxml(value))
        return locals()

    @Property
    def stationCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("stationCode"))
        def fset(self, value):
            self._element.set("stationCode", _string_toxml(value))
        return locals()

    @Property
    def locationCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("locationCode"))
        def fset(self, value):
            self._element.set("locationCode", _string_toxml(value))
        return locals()

    @Property
    def streamCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("streamCode"))
        def fset(self, value):
            self._element.set("streamCode", _string_toxml(value))
        return locals()

    # Aggregation: RouteArclink
    def _new_arclink(self):
        return xml_RouteArclink(ET.Element(xml_RouteArclink._xmlns + "arclink"))
    @property
    def arclink(self):
        for e1 in self._element.findall(xml_RouteArclink._xmlns + "arclink"):
            yield xml_RouteArclink(e1)

    # Aggregation: RouteSeedlink
    def _new_seedlink(self):
        return xml_RouteSeedlink(ET.Element(xml_RouteSeedlink._xmlns + "seedlink"))
    @property
    def seedlink(self):
        for e1 in self._element.findall(xml_RouteSeedlink._xmlns + "seedlink"):
            yield xml_RouteSeedlink(e1)


# Routing::Access
class xml_Access(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Access._xmlns + "access")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        self.networkCode = src.networkCode
        self.stationCode = src.stationCode
        self.locationCode = src.locationCode
        self.streamCode = src.streamCode
        self.user = src.user
        self.start = src.start
        self.end = src.end

    def _copy_to(self, dest):
        if self._element.get("networkCode") is not None:
            dest.networkCode = self.networkCode
        if self._element.get("stationCode") is not None:
            dest.stationCode = self.stationCode
        if self._element.get("locationCode") is not None:
            dest.locationCode = self.locationCode
        if self._element.get("streamCode") is not None:
            dest.streamCode = self.streamCode
        if self._element.get("user") is not None:
            dest.user = self.user
        if self._element.get("start") is not None:
            dest.start = self.start
        if self._element.get("end") is not None:
            dest.end = self.end

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    @Property
    def networkCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("networkCode"))
        def fset(self, value):
            self._element.set("networkCode", _string_toxml(value))
        return locals()

    @Property
    def stationCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("stationCode"))
        def fset(self, value):
            self._element.set("stationCode", _string_toxml(value))
        return locals()

    @Property
    def locationCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("locationCode"))
        def fset(self, value):
            self._element.set("locationCode", _string_toxml(value))
        return locals()

    @Property
    def streamCode():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("streamCode"))
        def fset(self, value):
            self._element.set("streamCode", _string_toxml(value))
        return locals()

    @Property
    def user():
    # type: string
        def fget(self):
            return _string_fromxml(self._element.get("user"))
        def fset(self, value):
            self._element.set("user", _string_toxml(value))
        return locals()

    @Property
    def start():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("start"))
        def fset(self, value):
            self._element.set("start", _datetime_toxml(value))
        return locals()

    @Property
    def end():
    # type: datetime
        def fget(self):
            return _datetime_fromxml(self._element.get("end"))
        def fset(self, value):
            self._element.set("end", _datetime_toxml(value))
        return locals()


# Routing::Routing
class xml_Routing(object):
    _xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
    def __init__(self, e = None):
        if e is None:
            self._element = ET.Element(xml_Routing._xmlns + "routing")
        else:
            self._element = e

    def _append_child(self, obj):
        self._element.append(obj._element)

    def _copy_from(self, src):
        pass


    def _copy_to(self, dest):
        pass

    @Property
    def publicID():
        def fget(self):
            return _string_fromxml(self._element.get("publicID"))
        def fset(self, value):
            self._element.set("publicID", _string_toxml(value))
        return locals()

    @Property
    def action():
        def fget(self):
            return _string_fromxml(self._element.get("action"))
        def fset(self, value):
            self._element.set("action", _string_toxml(value))
        return locals()

    # Aggregation: Route
    def _new_route(self):
        return xml_Route(ET.Element(xml_Route._xmlns + "route"))
    @property
    def route(self):
        for e1 in self._element.findall(xml_Route._xmlns + "route"):
            yield xml_Route(e1)

    # Aggregation: Access
    def _new_access(self):
        return xml_Access(ET.Element(xml_Access._xmlns + "access"))
    @property
    def access(self):
        for e1 in self._element.findall(xml_Access._xmlns + "access"):
            yield xml_Access(e1)
